Add node modules and compiled JavaScript from main (#54)

Co-authored-by: Oliver King <oking3@uncc.edu>

node_modules/jose/lib/jwa/ecdh/compute_secret.js

@@ -0,0 +1,43 @@
+const { improvedDH } = require('../../help/runtime_support')
+
+if (improvedDH) {
+  const { diffieHellman } = require('crypto')
+
+  const { KeyObject } = require('../../help/key_object')
+  const importKey = require('../../jwk/import')
+
+  module.exports = ({ keyObject: privateKey }, publicKey) => {
+    if (!(publicKey instanceof KeyObject)) {
+      ({ keyObject: publicKey } = importKey(publicKey))
+    }
+
+    return diffieHellman({ privateKey, publicKey })
+  }
+} else {
+  const { createECDH, constants: { POINT_CONVERSION_UNCOMPRESSED } } = require('crypto')
+
+  const base64url = require('../../help/base64url')
+
+  const crvToCurve = (crv) => {
+    switch (crv) {
+      case 'P-256':
+        return 'prime256v1'
+      case 'P-384':
+        return 'secp384r1'
+      case 'P-521':
+        return 'secp521r1'
+    }
+  }
+
+  const UNCOMPRESSED = Buffer.alloc(1, POINT_CONVERSION_UNCOMPRESSED)
+  const pubToBuffer = (x, y) => Buffer.concat([UNCOMPRESSED, base64url.decodeToBuffer(x), base64url.decodeToBuffer(y)])
+
+  module.exports = ({ crv, d }, { x, y }) => {
+    const curve = crvToCurve(crv)
+    const exchange = createECDH(curve)
+
+    exchange.setPrivateKey(base64url.decodeToBuffer(d))
+
+    return exchange.computeSecret(pubToBuffer(x, y))
+  }
+}

node_modules/jose/lib/jwa/ecdh/derive.js

@@ -0,0 +1,40 @@
+const { createHash } = require('crypto')
+const ecdhComputeSecret = require('./compute_secret')
+
+const concat = (key, length, value) => {
+  const iterations = Math.ceil(length / 32)
+  let res
+
+  for (let iter = 1; iter <= iterations; iter++) {
+    const buf = Buffer.allocUnsafe(4 + key.length + value.length)
+    buf.writeUInt32BE(iter, 0)
+    key.copy(buf, 4)
+    value.copy(buf, 4 + key.length)
+    if (!res) {
+      res = createHash('sha256').update(buf).digest()
+    } else {
+      res = Buffer.concat([res, createHash('sha256').update(buf).digest()])
+    }
+  }
+
+  return res.slice(0, length)
+}
+
+const uint32be = (value, buf = Buffer.allocUnsafe(4)) => {
+  buf.writeUInt32BE(value)
+  return buf
+}
+
+const lengthAndInput = input => Buffer.concat([uint32be(input.length), input])
+
+module.exports = (alg, keyLen, privKey, pubKey, { apu = Buffer.alloc(0), apv = Buffer.alloc(0) } = {}, computeSecret = ecdhComputeSecret) => {
+  const value = Buffer.concat([
+    lengthAndInput(Buffer.from(alg)),
+    lengthAndInput(apu),
+    lengthAndInput(apv),
+    uint32be(keyLen)
+  ])
+
+  const sharedSecret = computeSecret(privKey, pubKey)
+  return concat(sharedSecret, keyLen / 8, value)
+}

node_modules/jose/lib/jwa/ecdh/dir.js

@@ -0,0 +1,31 @@
+const { improvedDH } = require('../../help/runtime_support')
+const { KEYLENGTHS } = require('../../registry')
+const { generateSync } = require('../../jwk/generate')
+
+const derive = require('./derive')
+
+const wrapKey = (key, payload, { enc }) => {
+  const epk = generateSync(key.kty, key.crv)
+
+  const derivedKey = derive(enc, KEYLENGTHS.get(enc), epk, key)
+
+  return {
+    wrapped: derivedKey,
+    header: { epk: { kty: key.kty, crv: key.crv, x: epk.x, y: epk.y } }
+  }
+}
+
+const unwrapKey = (key, payload, header) => {
+  const { enc, epk } = header
+  return derive(enc, KEYLENGTHS.get(enc), key, epk, header)
+}
+
+module.exports = (JWA, JWK) => {
+  JWA.keyManagementEncrypt.set('ECDH-ES', wrapKey)
+  JWA.keyManagementDecrypt.set('ECDH-ES', unwrapKey)
+  JWK.EC.deriveKey['ECDH-ES'] = key => (key.use === 'enc' || key.use === undefined) && key.crv !== 'secp256k1'
+
+  if (improvedDH) {
+    JWK.OKP.deriveKey['ECDH-ES'] = key => (key.use === 'enc' || key.use === undefined) && key.keyObject.asymmetricKeyType.startsWith('x')
+  }
+}

node_modules/jose/lib/jwa/ecdh/kw.js

@@ -0,0 +1,47 @@
+const { improvedDH } = require('../../help/runtime_support')
+const { KEYOBJECT } = require('../../help/consts')
+const { generateSync } = require('../../jwk/generate')
+const { ECDH_DERIVE_LENGTHS } = require('../../registry')
+
+const derive = require('./derive')
+
+const wrapKey = (wrap, derive, key, payload) => {
+  const epk = generateSync(key.kty, key.crv)
+
+  const derivedKey = derive(epk, key, payload)
+
+  const result = wrap({ [KEYOBJECT]: derivedKey }, payload)
+  result.header = result.header || {}
+  Object.assign(result.header, { epk: { kty: key.kty, crv: key.crv, x: epk.x, y: epk.y } })
+
+  return result
+}
+
+const unwrapKey = (unwrap, derive, key, payload, header) => {
+  const { epk } = header
+  const derivedKey = derive(key, epk, header)
+
+  return unwrap({ [KEYOBJECT]: derivedKey }, payload, header)
+}
+
+module.exports = (JWA, JWK) => {
+  ['ECDH-ES+A128KW', 'ECDH-ES+A192KW', 'ECDH-ES+A256KW'].forEach((jwaAlg) => {
+    const kw = jwaAlg.substr(-6)
+    const kwWrap = JWA.keyManagementEncrypt.get(kw)
+    const kwUnwrap = JWA.keyManagementDecrypt.get(kw)
+    const keylen = parseInt(jwaAlg.substr(9, 3), 10)
+    ECDH_DERIVE_LENGTHS.set(jwaAlg, keylen)
+
+    if (kwWrap && kwUnwrap) {
+      JWA.keyManagementEncrypt.set(jwaAlg, wrapKey.bind(undefined, kwWrap, derive.bind(undefined, jwaAlg, keylen)))
+      JWA.keyManagementDecrypt.set(jwaAlg, unwrapKey.bind(undefined, kwUnwrap, derive.bind(undefined, jwaAlg, keylen)))
+      JWK.EC.deriveKey[jwaAlg] = key => (key.use === 'enc' || key.use === undefined) && key.crv !== 'secp256k1'
+
+      if (improvedDH) {
+        JWK.OKP.deriveKey[jwaAlg] = key => (key.use === 'enc' || key.use === undefined) && key.keyObject.asymmetricKeyType.startsWith('x')
+      }
+    }
+  })
+}
+module.exports.wrapKey = wrapKey
+module.exports.unwrapKey = unwrapKey