vue에서 rsa암호화 하여 자바와 통신하기

로그인시에 아이디와, 패스워드를 rsa로 암호화 하여 자바와 통신한다.

먼저 자바에서 rsa로 암호화에 필요한 공개키를 발행하여 vue단으로 넘긴다.

vue에서는 공개키를 이용하여 rsa암호화 하여 자바로 보내면, 자바에서 프라이빗 키로 복호화 하여 처리한다.

 

rsa 암호화 자바스크립트는 있는데 vue용으로 만들어진 rsa암호화 모듈이 없어서, rsa.js를 vue에서 사용할수 있도록

약간 컨버트 하였다.

소스는 총4개의 js파일이다.

js\rsa 폴더를 만든후에

1. jsbn.js 파일을 만들어서 저장한다.

/* eslint-disable */
const BigInteger = (function () {
  'use strict'
  // Bits per digit
  let dbits
  // JavaScript engine analysis
  const canary = 0xdeadbeefcafe
  const j_lm = ((canary & 0xffffff) == 0xefcafe)

  // (public) Constructor
  function BigInteger (a, b, c) {
    if (a != null) {
      if (typeof a === 'number') this.fromNumber(a, b, c)
      else if (b == null && typeof a !== 'string') this.fromString(a, 256)
      else this.fromString(a, b)
    }
  }

  // return new, unset BigInteger
  function nbi () { return new BigInteger(null) }

  function am1 (i, x, w, j, c, n) {
    while (--n >= 0) {
      const v = x * this[i++] + w[j] + c
      c = Math.floor(v / 0x4000000)
      w[j++] = v & 0x3ffffff
    }
    return c
  }

  function am2 (i, x, w, j, c, n) {
    const xl = x & 0x7fff; const xh = x >> 15
    while (--n >= 0) {
      let l = this[i] & 0x7fff
      const h = this[i++] >> 15
      const m = xh * l + h * xl
      l = xl * l + ((m & 0x7fff) << 15) + w[j] + (c & 0x3fffffff)
      c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30)
      w[j++] = l & 0x3fffffff
    }
    return c
  }

  function am3 (i, x, w, j, c, n) {
    const xl = x & 0x3fff; const xh = x >> 14
    while (--n >= 0) {
      let l = this[i] & 0x3fff
      const h = this[i++] >> 14
      const m = xh * l + h * xl
      l = xl * l + ((m & 0x3fff) << 14) + w[j] + c
      c = (l >> 28) + (m >> 14) + xh * h
      w[j++] = l & 0xfffffff
    }
    return c
  }

  if (j_lm && typeof window !== 'undefined' && (navigator.appName == 'Microsoft Internet Explorer')) {
    BigInteger.prototype.am = am2
    dbits = 30
  } else if (j_lm && typeof window !== 'undefined' && (navigator.appName != 'Netscape')) {
    BigInteger.prototype.am = am1
    dbits = 26
  } else { // Mozilla/Netscape seems to prefer am3
    BigInteger.prototype.am = am3
    dbits = 28
  }

  BigInteger.prototype.DB = dbits
  BigInteger.prototype.DM = ((1 << dbits) - 1)
  BigInteger.prototype.DV = (1 << dbits)

  const BI_FP = 52
  BigInteger.prototype.FV = Math.pow(2, BI_FP)
  BigInteger.prototype.F1 = BI_FP - dbits
  BigInteger.prototype.F2 = 2 * dbits - BI_FP

  // Digit conversions
  const BI_RM = '0123456789abcdefghijklmnopqrstuvwxyz'
  const BI_RC = new Array()
  let rr, vv
  rr = '0'.charCodeAt(0)
  for (vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv
  rr = 'a'.charCodeAt(0)
  for (vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv
  rr = 'A'.charCodeAt(0)
  for (vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv

  function int2char (n) { return BI_RM.charAt(n) }
  function intAt (s, i) {
    const c = BI_RC[s.charCodeAt(i)]
    return (c == null) ? -1 : c
  }

  // (protected) copy this to r
  function bnpCopyTo (r) {
    for (var i = this.t - 1; i >= 0; --i) r[i] = this[i]
    r.t = this.t
    r.s = this.s
  }

  // (protected) set from integer value x, -DV <= x < DV
  function bnpFromInt (x) {
    this.t = 1
    this.s = (x < 0) ? -1 : 0
    if (x > 0) this[0] = x
    else if (x < -1) this[0] = x + this.DV
    else this.t = 0
  }

  // return bigint initialized to value
  function nbv (i) { var r = nbi(); r.fromInt(i); return r }

  // (protected) set from string and radix
  function bnpFromString (s, b) {
    var k
    if (b == 16) k = 4
    else if (b == 8) k = 3
    else if (b == 256) k = 8 // byte array
    else if (b == 2) k = 1
    else if (b == 32) k = 5
    else if (b == 4) k = 2
    else { this.fromRadix(s, b); return }
    this.t = 0
    this.s = 0
    var i = s.length; var mi = false; var sh = 0
    while (--i >= 0) {
      var x = (k == 8) ? s[i] & 0xff : intAt(s, i)
      if (x < 0) {
        if (s.charAt(i) == '-') mi = true
        continue
      }
      mi = false
      if (sh == 0) { this[this.t++] = x } else if (sh + k > this.DB) {
        this[this.t - 1] |= (x & ((1 << (this.DB - sh)) - 1)) << sh
        this[this.t++] = (x >> (this.DB - sh))
      } else { this[this.t - 1] |= x << sh }
      sh += k
      if (sh >= this.DB) sh -= this.DB
    }
    if (k == 8 && (s[0] & 0x80) != 0) {
      this.s = -1
      if (sh > 0) this[this.t - 1] |= ((1 << (this.DB - sh)) - 1) << sh
    }
    this.clamp()
    if (mi) BigInteger.ZERO.subTo(this, this)
  }

  // (protected) clamp off excess high words
  function bnpClamp () {
    var c = this.s & this.DM
    while (this.t > 0 && this[this.t - 1] == c) --this.t
  }

  // (public) return string representation in given radix
  function bnToString (b) {
    if (this.s < 0) return '-' + this.negate().toString(b)
    var k
    if (b == 16) k = 4
    else if (b == 8) k = 3
    else if (b == 2) k = 1
    else if (b == 32) k = 5
    else if (b == 4) k = 2
    else return this.toRadix(b)
    var km = (1 << k) - 1; var d; var m = false; var r = ''; var i = this.t
    var p = this.DB - (i * this.DB) % k
    if (i-- > 0) {
      if (p < this.DB && (d = this[i] >> p) > 0) { m = true; r = int2char(d) }
      while (i >= 0) {
        if (p < k) {
          d = (this[i] & ((1 << p) - 1)) << (k - p)
          d |= this[--i] >> (p += this.DB - k)
        } else {
          d = (this[i] >> (p -= k)) & km
          if (p <= 0) { p += this.DB; --i }
        }
        if (d > 0) m = true
        if (m) r += int2char(d)
      }
    }
    return m ? r : '0'
  }

  // (public) -this
  function bnNegate () { var r = nbi(); BigInteger.ZERO.subTo(this, r); return r }

  // (public) |this|
  function bnAbs () { return (this.s < 0) ? this.negate() : this }

  // (public) return + if this > a, - if this < a, 0 if equal
  function bnCompareTo (a) {
    var r = this.s - a.s
    if (r != 0) return r
    var i = this.t
    r = i - a.t
    if (r != 0) return r
    while (--i >= 0) if ((r = this[i] - a[i]) != 0) return r
    return 0
  }

  // returns bit length of the integer x
  function nbits (x) {
    var r = 1; var t
    if ((t = x >>> 16) != 0) { x = t; r += 16 }
    if ((t = x >> 8) != 0) { x = t; r += 8 }
    if ((t = x >> 4) != 0) { x = t; r += 4 }
    if ((t = x >> 2) != 0) { x = t; r += 2 }
    if ((t = x >> 1) != 0) { x = t; r += 1 }
    return r
  }

  // (public) return the number of bits in "this"
  function bnBitLength () {
    if (this.t <= 0) return 0
    return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ (this.s & this.DM))
  }

  // (protected) r = this << n*DB
  function bnpDLShiftTo (n, r) {
    var i
    for (i = this.t - 1; i >= 0; --i) r[i + n] = this[i]
    for (i = n - 1; i >= 0; --i) r[i] = 0
    r.t = this.t + n
    r.s = this.s
  }

  // (protected) r = this >> n*DB
  function bnpDRShiftTo (n, r) {
    for (var i = n; i < this.t; ++i) r[i - n] = this[i]
    r.t = Math.max(this.t - n, 0)
    r.s = this.s
  }

  // (protected) r = this << n
  function bnpLShiftTo (n, r) {
    var bs = n % this.DB
    var cbs = this.DB - bs
    var bm = (1 << cbs) - 1
    var ds = Math.floor(n / this.DB); var c = (this.s << bs) & this.DM; var i
    for (i = this.t - 1; i >= 0; --i) {
      r[i + ds + 1] = (this[i] >> cbs) | c
      c = (this[i] & bm) << bs
    }
    for (i = ds - 1; i >= 0; --i) r[i] = 0
    r[ds] = c
    r.t = this.t + ds + 1
    r.s = this.s
    r.clamp()
  }

  // (protected) r = this >> n
  function bnpRShiftTo (n, r) {
    r.s = this.s
    var ds = Math.floor(n / this.DB)
    if (ds >= this.t) { r.t = 0; return }
    var bs = n % this.DB
    var cbs = this.DB - bs
    var bm = (1 << bs) - 1
    r[0] = this[ds] >> bs
    for (var i = ds + 1; i < this.t; ++i) {
      r[i - ds - 1] |= (this[i] & bm) << cbs
      r[i - ds] = this[i] >> bs
    }
    if (bs > 0) r[this.t - ds - 1] |= (this.s & bm) << cbs
    r.t = this.t - ds
    r.clamp()
  }

  // (protected) r = this - a
  function bnpSubTo (a, r) {
    var i = 0; var c = 0; var m = Math.min(a.t, this.t)
    while (i < m) {
      c += this[i] - a[i]
      r[i++] = c & this.DM
      c >>= this.DB
    }
    if (a.t < this.t) {
      c -= a.s
      while (i < this.t) {
        c += this[i]
        r[i++] = c & this.DM
        c >>= this.DB
      }
      c += this.s
    } else {
      c += this.s
      while (i < a.t) {
        c -= a[i]
        r[i++] = c & this.DM
        c >>= this.DB
      }
      c -= a.s
    }
    r.s = (c < 0) ? -1 : 0
    if (c < -1) r[i++] = this.DV + c
    else if (c > 0) r[i++] = c
    r.t = i
    r.clamp()
  }

  // (protected) r = this * a, r != this,a (HAC 14.12)
  // "this" should be the larger one if appropriate.
  function bnpMultiplyTo (a, r) {
    var x = this.abs(); var y = a.abs()
    var i = x.t
    r.t = i + y.t
    while (--i >= 0) r[i] = 0
    for (i = 0; i < y.t; ++i) r[i + x.t] = x.am(0, y[i], r, i, 0, x.t)
    r.s = 0
    r.clamp()
    if (this.s != a.s) BigInteger.ZERO.subTo(r, r)
  }

  // (protected) r = this^2, r != this (HAC 14.16)
  function bnpSquareTo (r) {
    var x = this.abs()
    var i = r.t = 2 * x.t
    while (--i >= 0) r[i] = 0
    for (i = 0; i < x.t - 1; ++i) {
      var c = x.am(i, x[i], r, 2 * i, 0, 1)
      if ((r[i + x.t] += x.am(i + 1, 2 * x[i], r, 2 * i + 1, c, x.t - i - 1)) >= x.DV) {
        r[i + x.t] -= x.DV
        r[i + x.t + 1] = 1
      }
    }
    if (r.t > 0) r[r.t - 1] += x.am(i, x[i], r, 2 * i, 0, 1)
    r.s = 0
    r.clamp()
  }

  // (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)
  // r != q, this != m.  q or r may be null.
  function bnpDivRemTo (m, q, r) {
    var pm = m.abs()
    if (pm.t <= 0) return
    var pt = this.abs()
    if (pt.t < pm.t) {
      if (q != null) q.fromInt(0)
      if (r != null) this.copyTo(r)
      return
    }
    if (r == null) r = nbi()
    var y = nbi(); var ts = this.s; var ms = m.s
    var nsh = this.DB - nbits(pm[pm.t - 1])	// normalize modulus
    if (nsh > 0) { pm.lShiftTo(nsh, y); pt.lShiftTo(nsh, r) } else { pm.copyTo(y); pt.copyTo(r) }
    var ys = y.t
    var y0 = y[ys - 1]
    if (y0 == 0) return
    var yt = y0 * (1 << this.F1) + ((ys > 1) ? y[ys - 2] >> this.F2 : 0)
    var d1 = this.FV / yt; var d2 = (1 << this.F1) / yt; var e = 1 << this.F2
    var i = r.t; var j = i - ys; var t = (q == null) ? nbi() : q
    y.dlShiftTo(j, t)
    if (r.compareTo(t) >= 0) {
      r[r.t++] = 1
      r.subTo(t, r)
    }
    BigInteger.ONE.dlShiftTo(ys, t)
    t.subTo(y, y)	// "negative" y so we can replace sub with am later
    while (y.t < ys) y[y.t++] = 0
    while (--j >= 0) {
      // Estimate quotient digit
      var qd = (r[--i] == y0) ? this.DM : Math.floor(r[i] * d1 + (r[i - 1] + e) * d2)
      if ((r[i] += y.am(0, qd, r, j, 0, ys)) < qd) {	// Try it out
        y.dlShiftTo(j, t)
        r.subTo(t, r)
        while (r[i] < --qd) r.subTo(t, r)
      }
    }
    if (q != null) {
      r.drShiftTo(ys, q)
      if (ts != ms) BigInteger.ZERO.subTo(q, q)
    }
    r.t = ys
    r.clamp()
    if (nsh > 0) r.rShiftTo(nsh, r)	// Denormalize remainder
    if (ts < 0) BigInteger.ZERO.subTo(r, r)
  }

  // (public) this mod a
  function bnMod (a) {
    var r = nbi()
    this.abs().divRemTo(a, null, r)
    if (this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r, r)
    return r
  }

  // Modular reduction using "classic" algorithm
  function Classic (m) { this.m = m }
  function cConvert (x) {
    if (x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m)
    else return x
  }
  function cRevert (x) { return x }
  function cReduce (x) { x.divRemTo(this.m, null, x) }
  function cMulTo (x, y, r) { x.multiplyTo(y, r); this.reduce(r) }
  function cSqrTo (x, r) { x.squareTo(r); this.reduce(r) }

  Classic.prototype.convert = cConvert
  Classic.prototype.revert = cRevert
  Classic.prototype.reduce = cReduce
  Classic.prototype.mulTo = cMulTo
  Classic.prototype.sqrTo = cSqrTo

  function bnpInvDigit () {
    if (this.t < 1) return 0
    var x = this[0]
    if ((x & 1) == 0) return 0
    var y = x & 3		// y == 1/x mod 2^2
    y = (y * (2 - (x & 0xf) * y)) & 0xf	// y == 1/x mod 2^4
    y = (y * (2 - (x & 0xff) * y)) & 0xff	// y == 1/x mod 2^8
    y = (y * (2 - (((x & 0xffff) * y) & 0xffff))) & 0xffff	// y == 1/x mod 2^16
    // last step - calculate inverse mod DV directly;
    // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints
    y = (y * (2 - x * y % this.DV)) % this.DV		// y == 1/x mod 2^dbits
    // we really want the negative inverse, and -DV < y < DV
    return (y > 0) ? this.DV - y : -y
  }

  // Montgomery reduction
  function Montgomery (m) {
    this.m = m
    this.mp = m.invDigit()
    this.mpl = this.mp & 0x7fff
    this.mph = this.mp >> 15
    this.um = (1 << (m.DB - 15)) - 1
    this.mt2 = 2 * m.t
  }

  // xR mod m
  function montConvert (x) {
    var r = nbi()
    x.abs().dlShiftTo(this.m.t, r)
    r.divRemTo(this.m, null, r)
    if (x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r, r)
    return r
  }

  // x/R mod m
  function montRevert (x) {
    var r = nbi()
    x.copyTo(r)
    this.reduce(r)
    return r
  }

  // x = x/R mod m (HAC 14.32)
  function montReduce (x) {
    while (x.t <= this.mt2)	// pad x so am has enough room later
    { x[x.t++] = 0 }
    for (var i = 0; i < this.m.t; ++i) {
      // faster way of calculating u0 = x[i]*mp mod DV
      var j = x[i] & 0x7fff
      var u0 = (j * this.mpl + (((j * this.mph + (x[i] >> 15) * this.mpl) & this.um) << 15)) & x.DM
      // use am to combine the multiply-shift-add into one call
      j = i + this.m.t
      x[j] += this.m.am(0, u0, x, i, 0, this.m.t)
      // propagate carry
      while (x[j] >= x.DV) { x[j] -= x.DV; x[++j]++ }
    }
    x.clamp()
    x.drShiftTo(this.m.t, x)
    if (x.compareTo(this.m) >= 0) x.subTo(this.m, x)
  }

  // r = "x^2/R mod m"; x != r
  function montSqrTo (x, r) { x.squareTo(r); this.reduce(r) }

  // r = "xy/R mod m"; x,y != r
  function montMulTo (x, y, r) { x.multiplyTo(y, r); this.reduce(r) }

  Montgomery.prototype.convert = montConvert
  Montgomery.prototype.revert = montRevert
  Montgomery.prototype.reduce = montReduce
  Montgomery.prototype.mulTo = montMulTo
  Montgomery.prototype.sqrTo = montSqrTo

  // (protected) true iff this is even
  function bnpIsEven () { return ((this.t > 0) ? (this[0] & 1) : this.s) == 0 }

  // (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79)
  function bnpExp (e, z) {
    if (e > 0xffffffff || e < 1) return BigInteger.ONE
    var r = nbi(); var r2 = nbi(); var g = z.convert(this); var i = nbits(e) - 1
    g.copyTo(r)
    while (--i >= 0) {
      z.sqrTo(r, r2)
      if ((e & (1 << i)) > 0) z.mulTo(r2, g, r)
      else { var t = r; r = r2; r2 = t }
    }
    return z.revert(r)
  }

  // (public) this^e % m, 0 <= e < 2^32
  function bnModPowInt (e, m) {
    var z
    if (e < 256 || m.isEven()) z = new Classic(m); else z = new Montgomery(m)
    return this.exp(e, z)
  }

  // protected
  BigInteger.prototype.copyTo = bnpCopyTo
  BigInteger.prototype.fromInt = bnpFromInt
  BigInteger.prototype.fromString = bnpFromString
  BigInteger.prototype.clamp = bnpClamp
  BigInteger.prototype.dlShiftTo = bnpDLShiftTo
  BigInteger.prototype.drShiftTo = bnpDRShiftTo
  BigInteger.prototype.lShiftTo = bnpLShiftTo
  BigInteger.prototype.rShiftTo = bnpRShiftTo
  BigInteger.prototype.subTo = bnpSubTo
  BigInteger.prototype.multiplyTo = bnpMultiplyTo
  BigInteger.prototype.squareTo = bnpSquareTo
  BigInteger.prototype.divRemTo = bnpDivRemTo
  BigInteger.prototype.invDigit = bnpInvDigit
  BigInteger.prototype.isEven = bnpIsEven
  BigInteger.prototype.exp = bnpExp

  // public
  BigInteger.prototype.toString = bnToString
  BigInteger.prototype.negate = bnNegate
  BigInteger.prototype.abs = bnAbs
  BigInteger.prototype.compareTo = bnCompareTo
  BigInteger.prototype.bitLength = bnBitLength
  BigInteger.prototype.mod = bnMod
  BigInteger.prototype.modPowInt = bnModPowInt

  // "constants"
  BigInteger.ZERO = nbv(0)
  BigInteger.ONE = nbv(1)

  return BigInteger
})()

console.log('BigInteger', BigInteger)
if (typeof module === 'object' && module.exports) {
  module.exports = BigInteger
}

2. prng4.js

/* eslint-disable */

const Arcfour = (function () {
  function Arcfour () {
    this.i = 0
    this.j = 0
    this.S = new Array()
  }

  // Initialize arcfour context from key, an array of ints, each from [0..255]
  function ARC4init (key) {
    var i, j, t
    for (i = 0; i < 256; ++i) { this.S[i] = i }
    j = 0
    for (i = 0; i < 256; ++i) {
      j = (j + this.S[i] + key[i % key.length]) & 255
      t = this.S[i]
      this.S[i] = this.S[j]
      this.S[j] = t
    }
    this.i = 0
    this.j = 0
  }

  function ARC4next () {
    var t
    this.i = (this.i + 1) & 255
    this.j = (this.j + this.S[this.i]) & 255
    t = this.S[this.i]
    this.S[this.i] = this.S[this.j]
    this.S[this.j] = t
    return this.S[(t + this.S[this.i]) & 255]
  }

  Arcfour.prototype.init = ARC4init
  Arcfour.prototype.next = ARC4next
  // Plug in your RNG constructor here
  function prng_newstate () {
    return new Arcfour()
  }

  // Pool size must be a multiple of 4 and greater than 32.
  // An array of bytes the size of the pool will be passed to init()
  // var rng_psize = 256;
  return prng_newstate()
})()

console.log('Arcfour', Arcfour)
if (typeof module === 'object' && module.exports) {
  module.exports = Arcfour
}

3. rng.js

/* eslint-disable */

var Arcfour = require('./prng4')

const SecureRandom = (function () {
  'use strict'

  var rng_state
  var rng_pool
  var rng_pptr
  var rng_psize = 256

  // Mix in a 32-bit integer into the pool
  function rng_seed_int (x) {
    rng_pool[rng_pptr++] ^= x & 255
    rng_pool[rng_pptr++] ^= (x >> 8) & 255
    rng_pool[rng_pptr++] ^= (x >> 16) & 255
    rng_pool[rng_pptr++] ^= (x >> 24) & 255
    if (rng_pptr >= rng_psize) rng_pptr -= rng_psize
  }

  // Mix in the current time (w/milliseconds) into the pool
  function rng_seed_time () {
    rng_seed_int(new Date().getTime())
  }

  // Initialize the pool with junk if needed.
  if (rng_pool == null) {
    rng_pool = new Array()
    rng_pptr = 0
    var t
    if (typeof window !== 'undefined' && navigator.appName == 'Netscape' && navigator.appVersion < '5' && window.crypto) {
      // Extract entropy (256 bits) from NS4 RNG if available
      var z = window.crypto.random(32)
      for (t = 0; t < z.length; ++t) { rng_pool[rng_pptr++] = z.charCodeAt(t) & 255 }
    }
    while (rng_pptr < rng_psize) { // extract some randomness from Math.random()
      t = Math.floor(65536 * Math.random())
      rng_pool[rng_pptr++] = t >>> 8
      rng_pool[rng_pptr++] = t & 255
    }
    rng_pptr = 0
    rng_seed_time()
    // rng_seed_int(window.screenX);
    // rng_seed_int(window.screenY);
  }

  function rng_get_byte () {
    if (rng_state == null) {
      rng_seed_time()
      rng_state = Arcfour // prng_newstate();
      rng_state.init(rng_pool)
      for (rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr) { rng_pool[rng_pptr] = 0 }
      rng_pptr = 0
      // rng_pool = null;
    }
    // TODO: allow reseeding after first request
    return rng_state.next()
  }

  function rng_get_bytes (ba) {
    var i
    for (i = 0; i < ba.length; ++i) ba[i] = rng_get_byte()
  }

  function SecureRandom () { }
  SecureRandom.prototype.nextBytes = rng_get_bytes

  return SecureRandom
})()

console.log('SecureRandom', SecureRandom)
if (typeof module === 'object' && module.exports) {
  module.exports = SecureRandom
}

4. rsa.js

/* eslint-disable */
var BigInteger = require('./jsbn')
var SecureRandom = require('./rng')

var rsa = (function () {
  'use strict'

  // convert a (hex) string to a bignum object
  function parseBigInt (str, r) {
    return new BigInteger(str, r)
  }
  /*
  function linebrk(s,n) {
    var ret = "";
    var i = 0;
    while(i + n < s.length) {
      ret += s.substring(i,i+n) + "\n";
      i += n;
    }
    return ret + s.substring(i,s.length);
  }

  function byte2Hex(b) {
    if(b < 0x10)
      return "0" + b.toString(16);
    else
      return b.toString(16);
  }
  */

  // PKCS#1 (type 2, random) pad input string s to n bytes, and return a bigint
  function pkcs1pad2 (s, n) {
    if (n < s.length + 11) { // TODO: fix for utf-8
      alert('Message too long for RSA')
      return null
    }
    var ba = new Array()
    var i = s.length - 1
    while (i >= 0 && n > 0) {
      var c = s.charCodeAt(i--)
      if (c < 128) { // encode using utf-8
        ba[--n] = c
      } else if ((c > 127) && (c < 2048)) {
        ba[--n] = (c & 63) | 128
        ba[--n] = (c >> 6) | 192
      } else {
        ba[--n] = (c & 63) | 128
        ba[--n] = ((c >> 6) & 63) | 128
        ba[--n] = (c >> 12) | 224
      }
    }
    ba[--n] = 0
    var rng = new SecureRandom()
    var x = new Array()
    while (n > 2) { // random non-zero pad
      x[0] = 0
      while (x[0] == 0) rng.nextBytes(x)
      ba[--n] = x[0]
    }
    ba[--n] = 2
    ba[--n] = 0
    return new BigInteger(ba)
  }

  // "empty" RSA key constructor
  function RSAKey () {
    this.n = null
    this.e = 0
    this.d = null
    this.p = null
    this.q = null
    this.dmp1 = null
    this.dmq1 = null
    this.coeff = null
  }

  // Set the public key fields N and e from hex strings
  function RSASetPublic (N, E) {
    if (N != null && E != null && N.length > 0 && E.length > 0) {
      this.n = parseBigInt(N, 16)
      this.e = parseInt(E, 16)
    } else { console.log('Invalid RSA public key') }
  }

  // Perform raw public operation on "x": return x^e (mod n)
  function RSADoPublic (x) {
    return x.constructor === BigInteger ? x.modPowInt(this.e, this.n) : ''
  }

  // Return the PKCS#1 RSA encryption of "text" as an even-length hex string
  function RSAEncrypt (text) {
    var m = pkcs1pad2(text, (this.n.bitLength() + 7) >> 3)
    if (m == null) return null
    var c = this.doPublic(m)
    if (c == null) return null
    var h = c.toString(16)
    if ((h.length & 1) == 0) return h; else return '0' + h
  }

  // protected
  RSAKey.prototype.doPublic = RSADoPublic

  // public
  RSAKey.prototype.setPublic = RSASetPublic
  RSAKey.prototype.encrypt = RSAEncrypt

  return RSAKey
})()

console.log('rsa', rsa)
if (typeof module === 'object' && module.exports) {
  module.exports = rsa
}