feat: compute private RSA key p, q, dp, dq, qi when omitted

resolves #26

lib/help/key_utils.js

@@ -3,6 +3,7 @@ const { createPublicKey } = require('crypto')
 const base64url = require('./base64url')
 const errors = require('../errors')
 const asn1 = require('./asn1')
+const computePrimes = require('./rsa_primes')
 const { OKP_CURVES, EC_CURVES } = require('./consts')
 
 const oidHexToCurve = new Map([
@@ -198,6 +199,8 @@ const jwkToPem = {
  if (!(jwk.p && jwk.q && jwk.dp && jwk.dq && jwk.qi)) {
  throw new errors.JWKImportFailed('all other private key parameters must be present when any one of them is present')
  }
+ } else {
+ jwk = computePrimes(jwk)
  }
 
  return RSAPrivateKey.encode({

lib/help/rsa_primes.js

@@ -0,0 +1,149 @@
+/* global BigInt */
+
+const { randomBytes } = require('crypto')
+
+const base64url = require('./base64url')
+
+const ZERO = BigInt(0)
+const ONE = BigInt(1)
+const TWO = BigInt(2)
+
+const toJWKParameter = n => base64url.encodeBuffer(Buffer.from(n.toString(16), 'hex'))
+const fromBuffer = buf => BigInt(`0x${buf.toString('hex')}`)
+const bitLength = n => n.toString(2).length
+
+const eGcdX = (a, b) => {
+ let x = ZERO
+ let y = ONE
+ let u = ONE
+ let v = ZERO
+
+ while (a !== ZERO) {
+ let q = b / a
+ let r = b % a
+ let m = x - (u * q)
+ let n = y - (v * q)
+ b = a
+ a = r
+ x = u
+ y = v
+ u = m
+ v = n
+ }
+ return x
+}
+
+const gcd = (a, b) => {
+ let shift = ZERO
+ while (!((a | b) & ONE)) {
+ a >>= ONE
+ b >>= ONE
+ shift++
+ }
+ while (!(a & ONE)) {
+ a >>= ONE
+ }
+ do {
+ while (!(b & ONE)) {
+ b >>= ONE
+ }
+ if (a > b) {
+ let x = a
+ a = b
+ b = x
+ }
+ b -= a
+ } while (b)
+
+ return a << shift
+}
+
+const modPow = (a, b, n) => {
+ a = toZn(a, n)
+ let result = ONE
+ let x = a
+ while (b > 0) {
+ var leastSignificantBit = b % TWO
+ b = b / TWO
+ if (leastSignificantBit === ONE) {
+ result = result * x
+ result = result % n
+ }
+ x = x * x
+ x = x % n
+ }
+ return result
+}
+
+const randBetween = (min, max) => {
+ const interval = max - min
+ const bitLen = bitLength(interval)
+ let rnd
+ do {
+ rnd = fromBuffer(randBits(bitLen))
+ } while (rnd > interval)
+ return rnd + min
+}
+
+const randBits = (bitLength) => {
+ const byteLength = Math.ceil(bitLength / 8)
+ const rndBytes = randomBytes(byteLength)
+ // Fill with 0's the extra bits
+ rndBytes[0] = rndBytes[0] & (2 ** (bitLength % 8) - 1)
+ return rndBytes
+}
+
+const toZn = (a, n) => {
+ a = a % n
+ return (a < 0) ? a + n : a
+}
+
+const odd = (n) => {
+ let r = n
+ while (r % TWO === ZERO) {
+ r = r / TWO
+ }
+ return r
+}
+
+const getPrimeFactors = (e, d, n) => {
+ const r = odd(e * d - ONE)
+
+ let y
+ do {
+ let i = modPow(randBetween(TWO, n), r, n)
+ let o = ZERO
+ while (i !== ONE) {
+ o = i
+ i = (i * i) % n
+ }
+ if (o !== (n - ONE)) {
+ y = o
+ }
+ } while (!y)
+
+ const p = gcd(y - ONE, n)
+ const q = n / p
+
+ return p > q ? { p, q } : { p: q, q: p }
+}
+
+module.exports = (jwk) => {
+ const e = fromBuffer(base64url.decodeToBuffer(jwk.e))
+ const d = fromBuffer(base64url.decodeToBuffer(jwk.d))
+ const n = fromBuffer(base64url.decodeToBuffer(jwk.n))
+
+ const { p, q } = getPrimeFactors(e, d, n)
+ const dp = d % (p - ONE)
+ const dq = d % (q - ONE)
+ const qi = toZn(eGcdX(toZn(q, p), p), p)
+
+ return {
+ ...jwk,
+ p: toJWKParameter(p),
+ q: toJWKParameter(q),
+ dp: toJWKParameter(dp),
+ dq: toJWKParameter(dq),
+ qi: toJWKParameter(qi)
+ }
+}

test/jwe/smoke.test.js

@@ -3,7 +3,7 @@ const test = require('ava')
 const { randomBytes } = require('crypto')
 
 const { encrypt, decrypt } = require('../../lib/jwe')
-const { JWK: { importKey }, errors } = require('../..')
+const { JWK: { importKey, generateSync }, errors } = require('../..')
 
 const PAYLOAD = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c'
 const ENCS = [
@@ -119,3 +119,16 @@ Object.entries(fixtures.PEM).forEach(([type, { private: key, public: pub }]) =>
  })
  })
 })
+
+{
+ const rsa = generateSync('RSA')
+ const dKey = importKey({ kty: 'RSA', e: rsa.e, n: rsa.n, d: rsa.d })
+ const eKey = importKey({ kty: 'RSA', e: rsa.e, n: rsa.n })
+ eKey.algorithms('wrapKey').forEach((alg) => {
+ ENCS.forEach((enc) => {
+ if (alg === 'ECDH-ES' && ['A192CBC-HS384', 'A256CBC-HS512'].includes(enc)) return
+ test(`key RSA (min) > alg ${alg} > ${enc}`, success, eKey, dKey, alg, enc)
+ test(`key RSA (min) > alg ${alg} > ${enc} (negative cases)`, failure, eKey, dKey, alg, enc)
+ })
+ })
+}

test/jwk/import.test.js

@@ -1,7 +1,7 @@
 const test = require('ava')
 const crypto = require('crypto')
 
-const { JWK: { importKey, generate }, errors } = require('../..')
+const { JWS, JWE, JWK: { importKey, generate }, errors } = require('../..')
 
 const fixtures = require('../fixtures')
 
@@ -86,6 +86,20 @@ test('failed to import throws an error', t => {
  })
 })
 
+test('minimal RSA test', async t => {
+ const key = await generate('RSA')
+ const { d, e, n } = key.toJWK(true)
+ const minKey = importKey({ kty: 'RSA', d, e, n })
+ key.algorithms('sign').forEach((alg) => {
+ JWS.verify(JWS.sign({}, key), minKey, { alg })
+ JWS.verify(JWS.sign({}, minKey), key, { alg })
+ })
+ key.algorithms('wrapKey').forEach((alg) => {
+ JWE.decrypt(JWE.encrypt('foo', key), minKey, { alg })
+ JWE.decrypt(JWE.encrypt('foo', minKey), key, { alg })
+ })
+ t.pass()
+})
 
 test('fails to import RSA without all optimization parameters', async t => {
  const full = (await generate('RSA')).toJWK(true)

test/jws/smoke.test.js

@@ -75,3 +75,13 @@ sym.algorithms('sign').forEach((alg) => {
  test(`key ${sym.kty} > alg ${alg}`, success, sym, sym, alg)
  test(`key ${sym.kty} > alg ${alg} (negative cases)`, failure, sym, sym, alg)
 })
+
+{
+ const rsa = generateSync('RSA')
+ const sKey = importKey({ kty: 'RSA', e: rsa.e, n: rsa.n, d: rsa.d })
+ const vKey = importKey({ kty: 'RSA', e: rsa.e, n: rsa.n })
+ sKey.algorithms('sign').forEach((alg) => {
+ test(`key RSA (min) > alg ${alg}`, success, sKey, vKey, alg)
+ test(`key RSA (min) > alg ${alg} (negative cases)`, failure, sKey, vKey, alg)
+ })
+}