From 1c1f112ff57530a5bfca310bd981ee69949cd526 Mon Sep 17 00:00:00 2001 From: Vladislav Hristov Date: Wed, 30 Oct 2019 10:53:03 +0200 Subject: [PATCH 1/9] fix: modulus zero byte handling --- lib/orders/H004/response.js | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/lib/orders/H004/response.js b/lib/orders/H004/response.js index 66239df..eddaa3b 100644 --- a/lib/orders/H004/response.js +++ b/lib/orders/H004/response.js @@ -126,8 +126,9 @@ module.exports = (xml, keys) => ({ const type = lastChild(keyNodes[i].parentNode).textContent; const modulus = xpath.select(".//*[local-name(.)='Modulus']", keyNodes[i])[0].textContent; const exponent = xpath.select(".//*[local-name(.)='Exponent']", keyNodes[i])[0].textContent; + const modulusBuffer = Buffer.from(modulus, 'base64'); - const mod = new BN(Buffer.from(modulus, 'base64'), 2).toBuffer(); + const mod = new BN(Buffer.from(modulus, 'base64'), 2).toBuffer('be', modulusBuffer.length); const exp = new BN(Buffer.from(exponent, 'base64')).toNumber(); bankKeys[`bank${type}`] = { mod, exp }; From 4149c0169516181c90d01d2018cb89d49e43caff Mon Sep 17 00:00:00 2001 From: Vladislav Hristov Date: Thu, 31 Oct 2019 18:57:42 +0200 Subject: [PATCH 2/9] wip: migrate to node-forge --- lib/BankLetter.js | 1 - lib/keymanagers/keyRSA.js | 234 +++++++++++++++++++++++++++++++----- lib/orders/H004/response.js | 13 +- package.json | 1 + test/exponentHandle.js | 44 +++++++ test/fixtures/keys.js | 43 +++++++ test/keys.js | 86 +++++++++++++ 7 files changed, 384 insertions(+), 38 deletions(-) create mode 100644 test/exponentHandle.js create mode 100644 test/fixtures/keys.js create mode 100644 test/keys.js diff --git a/lib/BankLetter.js b/lib/BankLetter.js index 400766e..1221b22 100644 --- a/lib/BankLetter.js +++ b/lib/BankLetter.js @@ -25,7 +25,6 @@ const registerHelpers = () => { handlebars.registerHelper('sha256', (k) => { const digest = Buffer.from(Crypto.digestPublicKey(k), 'base64').toString('HEX'); // const digest = Buffer.from(k.publicDigest(), 'base64').toString('HEX'); - return digest.toUpperCase().match(/.{1,2}/g).join(' '); }); }; diff --git a/lib/keymanagers/keyRSA.js b/lib/keymanagers/keyRSA.js index a3c59a8..d48d3c1 100644 --- a/lib/keymanagers/keyRSA.js +++ b/lib/keymanagers/keyRSA.js @@ -1,49 +1,219 @@ 'use strict'; +/* eslint-disable camelcase */ + +function rsaPublicKeyPem(modulus_b64, exponent_b64) { + function prepadSigned(hexStr) { + const msb = hexStr[0]; + if ( + (msb >= '8' && msb <= '9') || + (msb >= 'a' && msb <= 'f') || + (msb >= 'A' && msb <= 'F')) + return `00${hexStr}`; + + return hexStr; + } + + function toHex(number) { + const nstr = number.toString(16); + if (nstr.length % 2 === 0) return nstr; + return `0${nstr}`; + } + + // encode ASN.1 DER length field + // if <=127, short from + // if >=128, long from + function encodeLengthHex(n) { + if (n <= 127) return toHex(n); + + const n_hex = toHex(n); + const length_of_length_byte = 128 + (n_hex.length / 2); // 0x80+numbytes + return toHex(length_of_length_byte) + n_hex; + } + + const modulus = Buffer.from(modulus_b64, 'base64'); + const exponent = Buffer.from(exponent_b64, 'base64'); + + let modulus_hex = modulus.toString('hex'); + let exponent_hex = exponent.toString('hex'); + + modulus_hex = prepadSigned(modulus_hex); + exponent_hex = prepadSigned(exponent_hex); + + const modlen = modulus_hex.length / 2; + const explen = exponent_hex.length / 2; + + const encoded_modlen = encodeLengthHex(modlen); + const encoded_explen = encodeLengthHex(explen); + const encoded_pubkey = `30${ + encodeLengthHex(modlen + explen + (encoded_modlen.length / 2) + (encoded_explen.length / 2) + 2) + }02${encoded_modlen}${modulus_hex + }02${encoded_explen}${exponent_hex}`; + + let seq2 = + `${'30 0d ' + + '06 09 2a 86 48 86 f7 0d 01 01 01' + + '05 00 ' + + '03'}${encodeLengthHex((encoded_pubkey.length / 2) + 1) + }00${encoded_pubkey}`; + + seq2 = seq2.replace(/ /g, ''); + + let der_hex = `30${encodeLengthHex(seq2.length / 2)}${seq2}`; + + der_hex = der_hex.replace(/ /g, ''); + + const der = Buffer.from(der_hex, 'hex'); + const der_b64 = der.toString('base64'); + + const pem = `-----BEGIN PUBLIC KEY-----\n${ + der_b64.match(/.{1,64}/g).join('\n') + }\n-----END PUBLIC KEY-----\n`; + + return pem.trim(); +} + const BN = require('bn.js'); const NodeRSA = require('node-rsa'); -const keyOrNull = (encodedKey) => { - if (encodedKey === null) return new NodeRSA(); +const { pki: { + rsa, publicKeyToPem, privateKeyToPem, publicKeyFromPem, privateKeyFromPem +}, jsbn: { BigInteger } } = require('node-forge'); - return (encodedKey instanceof NodeRSA) ? encodedKey : new NodeRSA(encodedKey); +const isKeyInstance = (obj) => { + if (typeof obj !== 'object') + return false; + return ('publicKey' in obj && 'privateKey' in obj); }; -module.exports = encodedKey => ({ - key: keyOrNull(encodedKey), +const getKeyType = (str) => { + const matches = str.match(/(PRIVATE|PUBLIC) KEY/); + if (!matches) + return null; + return matches[1].toLowerCase(); +}; - generate(keySize = 2048) { - return new NodeRSA({ b: keySize }); - }, +/* +class RsaKeyPair { + constructor() { + this._isPublic = null; + this._publicKey = null; + this._privateKey = null; + } + fromString(str) { - importKey({ mod, exp }) { - this.key = new NodeRSA(); - this.key.importKey({ n: mod, e: exp }, 'components-public'); + } +} +*/ - return this; - }, +const keyOrNull = (encodedKey) => { + if (encodedKey === null) return {}; + if (typeof encodedKey === 'string') { + const type = getKeyType(encodedKey); + const isPublic = type === 'public'; + const key = isPublic ? publicKeyFromPem(encodedKey) : privateKeyFromPem(encodedKey); + key.isPublic = isPublic; + return key; + } - n(to = 'buff') { - const keyN = Buffer.from(this.key.exportKey('components-public').n); + return encodedKey; + // return (isKeyInstance(encodedKey)) ? encodedKey; - return to === 'hex' - ? keyN.toString('hex', 1) - : keyN; - }, + /* const k = (encodedKey instanceof NodeRSA) ? encodedKey : new NodeRSA(encodedKey); + if (k.keyPair.e === 16777216) + k.keyPair.e = 4294967311; + return k; */ +}; - e(to = 'buff') { - const eKey = new BN(this.key.exportKey('components-public').e).toBuffer(); +module.exports = (encodedKey) => { + if (encodedKey && encodedKey.__RsaKey) + return encodedKey; + return { + __RsaKey: true, + key: keyOrNull(encodedKey), - return to === 'hex' - ? eKey.toString('hex') - : eKey; - }, + generate(keySize = 2048) { + const keyPair = rsa.generateKeyPair(keySize); + this.key = keyPair.privateKey; + this.key.isPublic = false; + this.publicKey = keyPair.publicKey; + return this; + // return rsa.generateKeyPair(keySize); + // return new NodeRSA({ b: keySize }); + }, - d() { - return this.key.keyPair.d.toBuffer(); - }, + importKey({ + mod, + exp, + modulus, + exponent, + }) { + this.key = rsa.setPublicKey(new BigInteger(mod.toString('hex'), 16), new BigInteger(exp.toString('hex'), 16)); + this.key.isPublic = true; + // const k = rsa.generateKeyPair(); + // k.publicKey = rsa.setPublicKey(mod, exp); + // this.key = k; + // this.key.publicKey. - toPem() { - return this.key.isPrivate() ? this.key.exportKey('pkcs1-private-pem') : this.key.exportKey('pkcs8-public-pem'); - }, -}); + // .this.key.importKey({ n: mod, e: exp }, 'components-public'); + /* + this.pempem = modulus && exponent ? { + modulus, + exponent, + } : null; + */ + + return this; + }, + + n(to = 'buff') { + const key = this.publicKey || this.key; + const keyN = Buffer.from(key.n.toByteArray()); + + return to === 'hex' + ? keyN.toString('hex', 1) + : keyN; + }, + + e(to = 'buff') { + const key = this.publicKey || this.key; + const eKey = Buffer.from(key.e.toByteArray()); // new BN(this.key.exportKey('components-public').e).toBuffer(); + + return to === 'hex' + ? eKey.toString('hex') + : eKey; + }, + + d() { + return Buffer.from(this.key.d.toByteArray()); + // return this.key.keyPair.d.toBuffer(); + }, + + isPrivate() { + return !this.key.isPublic; + }, + + isPublic() { + return this.key.isPublic; + // return this.key.isPublic(); + }, + + size() { + return 2048; + // return this.key.getKeySize(); + }, + + toPem() { + if (this.isPublic()) + return publicKeyToPem(this.key); + return privateKeyToPem(this.key); + /* + if (this.pempem) + return rsaPublicKeyPem(this.pempem.modulus, this.pempem.exponent); + const isPrivate = this.key.isPrivate(); + const pem = isPrivate ? this.key.exportKey('pkcs1-private-pem') : this.key.exportKey('pkcs8-public-pem'); + return pem; + */ + }, + }; +}; diff --git a/lib/orders/H004/response.js b/lib/orders/H004/response.js index eddaa3b..4e5a0b6 100644 --- a/lib/orders/H004/response.js +++ b/lib/orders/H004/response.js @@ -126,12 +126,15 @@ module.exports = (xml, keys) => ({ const type = lastChild(keyNodes[i].parentNode).textContent; const modulus = xpath.select(".//*[local-name(.)='Modulus']", keyNodes[i])[0].textContent; const exponent = xpath.select(".//*[local-name(.)='Exponent']", keyNodes[i])[0].textContent; - const modulusBuffer = Buffer.from(modulus, 'base64'); - const mod = new BN(Buffer.from(modulus, 'base64'), 2).toBuffer('be', modulusBuffer.length); - const exp = new BN(Buffer.from(exponent, 'base64')).toNumber(); - - bankKeys[`bank${type}`] = { mod, exp }; + const mod = Buffer.from(modulus, 'base64'); + const exp = Buffer.from(exponent, 'base64'); + bankKeys[`bank${type}`] = { + mod, + exp, + modulus, + exponent, + }; } return bankKeys; diff --git a/package.json b/package.json index d735e43..f48d4a4 100644 --- a/package.json +++ b/package.json @@ -33,6 +33,7 @@ "handlebars": "^4.4.3", "js2xmlparser": "^4.0.0", "moment": "^2.24.0", + "node-forge": "^0.9.1", "node-rsa": "^1.0.6", "request": "^2.88.0", "uuid": "^3.3.3", diff --git a/test/exponentHandle.js b/test/exponentHandle.js new file mode 100644 index 0000000..1f85741 --- /dev/null +++ b/test/exponentHandle.js @@ -0,0 +1,44 @@ +'use strict'; + +const { assert } = require('chai'); +const H004Response = require('../lib/orders/H004/response'); + +describe('H004 response parsing', () => { + it('parses bank keys exp', () => { + const response = H004Response('', {}); + + const x002mod = 'AJ2/0OoIZydb9sgKbiwqDcwA0NtcUMIYi6GK7PqoRszu1uytGnxJjQhGt62kMslWvLgebUSwdq/T3YyGsa3KQeIGaUUn9iqyu3BoNOMdo2DLN4NdGMY1WR/HbYRKR3JHyURhTBKw27KScRRdKGl6jY+VcXcTKJL8PjXMQH5cD6Gz'; // 'ALr6oSdqbbpRxlJmKtwTjjaCA1zlA61Vd7NfPML1NxY/U3Dt8galrieRjBM0SDn4vD2+AJCQY4zzkdE2m8u/p+3KGtmZtGaaxs11TNRm9GhtwQGw2hW73RduTSwLZJrSilv/GH18vPar8uvlBAXTmtVEy2kfvT3+t1mvqrut/LnUg3t63nx3WVdWylEdVDmf9Ylp+W+2quLyE0TzTVl5OXhvB3tpVs2B4OfsmOHJAaKIdSuXDMJebPiM9uIlraiJVeRMjkW3Xxmrazc7+kuy8RZ4BBgi+Xve6lNaQHGqxPV5q5SeXR5fS0D2sPeewJWbjhaVRBObIV2ZEoEWKx79pnE='; + const e002mod = 'AOzWaiT7aGESXcI3dqLY3RRD36inlZTGmNNprKd/t9uHfoMeLwZHeMwtjCRWjsuZEyBupkNSFWb3vBlxDyhcyTgpbbbcHsDGqF2zCJaK85xUphoH9mKHxbnA8ZlXzmtHwDmwVSns0FAslIqD+Xr+WycQpeCBEK12D8Ii032YS814ZUKHJ1MkS65A5PE0lcvMTyIE7ruG1kFz85F4nX8eWq77mDEiBONkA5RSUb5duGnRohdNYBgO8K6Wn18aDdISGDyPyXHNvC70v8tfWbF9VGE3rXVGcgjpezZZxC8d47vL0x6lOeslgl7s8N456ntAa+oGHRurt5mEhDz1DZg+EJc='; + const exponent = 'AQAB'; // 'AQAAAA8='; + + response.orderData = () => ` + + + + + ${x002mod} + ${exponent} + + 2015-02-25T08:01:13.061Z + + X002 + + + + + ${e002mod} + ${exponent} + + 2015-02-25T08:01:12.344Z + + E002 + + SBKPR01 + `; + + const bankKeys = response.bankKeys(); + + assert.equal(bankKeys.bankX002.mod.toString('base64'), x002mod); + assert.equal(bankKeys.bankE002.mod.toString('base64'), e002mod); + }); +}); diff --git a/test/fixtures/keys.js b/test/fixtures/keys.js new file mode 100644 index 0000000..f8a37df --- /dev/null +++ b/test/fixtures/keys.js @@ -0,0 +1,43 @@ +'use strict'; + +const publicSmallExpPEM = ''; +const publicSmallExpMod = ''; +const publicSmallExpExp = ''; + +const publicBigPEM = `-----BEGIN PUBLIC KEY----- +MIIBJDANBgkqhkiG9w0BAQEFAAOCAREAMIIBDAKCAQEAuvqhJ2ptulHGUmYq3BOO +NoIDXOUDrVV3s188wvU3Fj9TcO3yBqWuJ5GMEzRIOfi8Pb4AkJBjjPOR0Taby7+n +7coa2Zm0ZprGzXVM1Gb0aG3BAbDaFbvdF25NLAtkmtKKW/8YfXy89qvy6+UEBdOa +1UTLaR+9Pf63Wa+qu638udSDe3refHdZV1bKUR1UOZ/1iWn5b7aq4vITRPNNWXk5 +eG8He2lWzYHg5+yY4ckBooh1K5cMwl5s+Iz24iWtqIlV5EyORbdfGatrNzv6S7Lx +FngEGCL5e97qU1pAcarE9XmrlJ5dHl9LQPaw957AlZuOFpVEE5shXZkSgRYrHv2m +cQIFAQAAAA8= +-----END PUBLIC KEY-----`; +const publicBigModString = 'ALr6oSdqbbpRxlJmKtwTjjaCA1zlA61Vd7NfPML1NxY/U3Dt8galrieRjBM0SDn4vD2+AJCQY4zzkdE2m8u/p+3KGtmZtGaaxs11TNRm9GhtwQGw2hW73RduTSwLZJrSilv/GH18vPar8uvlBAXTmtVEy2kfvT3+t1mvqrut/LnUg3t63nx3WVdWylEdVDmf9Ylp+W+2quLyE0TzTVl5OXhvB3tpVs2B4OfsmOHJAaKIdSuXDMJebPiM9uIlraiJVeRMjkW3Xxmrazc7+kuy8RZ4BBgi+Xve6lNaQHGqxPV5q5SeXR5fS0D2sPeewJWbjhaVRBObIV2ZEoEWKx79pnE='; +const publicBigModBytes = [0, 186, 250, 161, 39, 106, 109, 186, 81, 198, 82, 102, 42, 220, 19, 142, 54, 130, 3, 92, 229, 3, 173, 85, 119, 179, 95, 60, 194, 245, 55, 22, 63, 83, 112, 237, 242, 6, 165, 174, 39, 145, 140, 19, 52, 72, 57, 248, 188, 61, 190, 0, 144, 144, 99, 140, 243, 145, 209, 54, 155, 203, 191, 167, 237, 202, 26, 217, 153, 180, 102, 154, 198, 205, 117, 76, 212, 102, 244, 104, 109, 193, 1, 176, 218, 21, 187, 221, 23, 110, 77, 44, 11, 100, 154, 210, 138, 91, 255, 24, 125, 124, 188, 246, 171, 242, 235, 229, 4, 5, 211, 154, 213, 68, 203, 105, 31, 189, 61, 254, 183, 89, 175, 170, 187, 173, 252, 185, 212, 131, 123, 122, 222, 124, 119, 89, 87, 86, 202, 81, 29, 84, 57, 159, 245, 137, 105, 249, 111, 182, 170, 226, 242, 19, 68, 243, 77, 89, 121, 57, 120, 111, 7, 123, 105, 86, 205, 129, 224, 231, 236, 152, 225, 201, 1, 162, 136, 117, 43, 151, 12, 194, 94, 108, 248, 140, 246, 226, 37, 173, 168, 137, 85, 228, 76, 142, 69, 183, 95, 25, 171, 107, 55, 59, 250, 75, 178, 241, 22, 120, 4, 24, 34, 249, 123, 222, 234, 83, 90, 64, 113, 170, 196, 245, 121, 171, 148, 158, 93, 30, 95, 75, 64, 246, 176, 247, 158, 192, 149, 155, 142, 22, 149, 68, 19, 155, 33, 93, 153, 18, 129, 22, 43, 30, 253, 166, 113]; +const publicBigExpString = 'AQAAAA8='; +const publicBigExpBytes = [1, 0, 0, 0, 15]; + + +const pblc = { + big: { + pem: publicBigPEM, + mod: { + bytes: publicBigModBytes, + string: publicBigModString, + }, + exp: { + bytes: publicBigExpBytes, + string: publicBigExpString, + }, + }, + small: { + pem: publicSmallExpPEM, + mod: publicSmallExpMod, + exp: publicSmallExpExp, + }, +}; + +module.exports = { + pblc, +}; diff --git a/test/keys.js b/test/keys.js new file mode 100644 index 0000000..c9736e1 --- /dev/null +++ b/test/keys.js @@ -0,0 +1,86 @@ +'use strict'; + +const { assert } = require('chai'); +const fixtures = require('./fixtures/keys'); +const Key = require('../lib/keymanagers/keyRSA'); + +const stripWhitespace = str => str.replace(/\s+/g, ''); + +describe('Keys management', () => { + describe('generates brand new', () => { + const keySize = 2048; + const newKey = Key().generate(keySize); + + // newKey.key = Key().generate(keySize); + + it('private key', () => { + assert.isTrue(newKey.isPrivate()); + }); + + it('that has the right key size', () => { + // const newKeySize = newKey.size(); // console.log(newKey.size()); + assert(newKey.size(), keySize); + }); + }); + + describe('creates public key from mod and exp', () => { + const { pem, mod, exp } = fixtures.pblc.big; + + describe('that are strings', () => { + const m = Buffer.from(mod.string, 'base64'); + const e = Buffer.from(exp.string, 'base64'); + const newKey = Key().importKey({ + mod: m, exp: e, modulus: mod.string, exponent: exp.string, + }); + + it('and is really public', () => { + assert.isTrue(newKey.isPublic()); + }); + + it('and has a propper mod in bytes', () => { + assert.deepEqual([...newKey.n()], mod.bytes); + }); + + it('and has a propper pem string', () => { + assert.equal(stripWhitespace(newKey.toPem()), stripWhitespace(pem)); + }); + }); + + describe('that are bytes', () => { + const m = Buffer.from(mod.bytes); + const e = Buffer.from(exp.bytes); + const newKey = Key().importKey({ + mod: m, exp: e, modulus: mod.string, exponent: exp.string, + }); + + it('and is really public', () => { + assert.isTrue(newKey.isPublic()); + }); + + it('and has a propper mod as a string', () => { + assert.equal(newKey.n().toString('base64'), mod.string); + }); + + it('and has a propper pem string', () => { + assert.equal(stripWhitespace(newKey.toPem()), stripWhitespace(pem)); + }); + }); + }); + + describe('creates public key from pem string', () => { + const { pem, mod, exp } = fixtures.pblc.big; + const newKey = Key(pem); + + it('and is really public', () => { + assert.isTrue(newKey.isPublic()); + }); + + it('and has a propper(the same) pem string', () => { + newKey.pempem = { + modulus: mod.string, + exponent: exp.string, + }; + assert.equal(stripWhitespace(newKey.toPem()), stripWhitespace(pem)); + }); + }); +}); From f15e09840ae114753d7fe2e323c0dced2c5afc13 Mon Sep 17 00:00:00 2001 From: Vladislav Hristov Date: Fri, 1 Nov 2019 13:44:29 +0200 Subject: [PATCH 3/9] add: add Key class to manage a single key --- lib/keymanagers/Key.js | 137 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 137 insertions(+) create mode 100644 lib/keymanagers/Key.js diff --git a/lib/keymanagers/Key.js b/lib/keymanagers/Key.js new file mode 100644 index 0000000..1f17e78 --- /dev/null +++ b/lib/keymanagers/Key.js @@ -0,0 +1,137 @@ +'use strict'; + +const { + pki: { + rsa, + publicKeyToPem, + privateKeyToPem, + publicKeyFromPem, + privateKeyFromPem, + }, + jsbn: { + BigInteger, + }, +} = require('node-forge'); + +const getKeyType = (str) => { + const matches = str.match(/(PRIVATE|PUBLIC) KEY/); + if (!matches) + return null; + return matches[1].toLowerCase(); +}; + +const keyFromPem = (pem) => { + const type = getKeyType(pem); + const isPublic = type === 'public'; + const key = isPublic ? publicKeyFromPem(pem) : privateKeyFromPem(pem); + + return { + isPublic, + key, + }; +}; + +/** + * Creates a public key from modulus and exponent + * @param {Buffer} mod - the modulus + * @param {Buffer} exp - the exponent + */ +const keyFromModAndExp = (mod, exp) => { + const bnMod = new BigInteger(mod.toString('hex'), 16); + const bnExp = new BigInteger(exp.toString('hex'), 16); + + return { + key: rsa.setPublicKey(bnMod, bnExp), + isPublic: true, + }; +}; + +module.exports = class Key { + constructor({ + pem = null, mod = null, exp = null, size = 2048, + } = {}) { + // generate new private key + if (!pem && !mod && !exp) { + const keyPair = rsa.generateKeyPair(size); + + this.keyIsPublic = false; + this.privateKey = keyPair.privateKey; + this.publicKey = keyPair.publicKey; + + return; + } + + // new key from pem string + if (pem) { + const { key, isPublic } = keyFromPem(pem); + + this.keyIsPublic = isPublic; + this.privateKey = isPublic ? null : key; + this.publicKey = isPublic ? key : null; + + return; + } + + // new key from mod and exp + if (mod && exp) { + const { key, isPublic } = keyFromModAndExp(mod, exp); + + this.keyIsPublic = isPublic; + this.privateKey = isPublic ? null : key; + this.publicKey = isPublic ? key : null; + + return; + } + + // not good + throw new Error(`Can not create key without ${!mod ? 'modulus' : 'exponent'}.`); + } + + static generate(size = 2048) { + return new Key({ size }); + } + + static importKey({ mod, exp }) { + return new Key({ mod, exp }); + } + + n(to = 'buff') { + const key = this.keyIsPublic ? this.publicKey : this.privateKey; + const keyN = Buffer.from(key.n.toByteArray()); + + return to === 'hex' ? keyN.toString('hex', 1) : keyN; + } + + e(to = 'buff') { + const key = this.keyIsPublic ? this.publicKey : this.privateKey; + const eKey = Buffer.from(key.e.toByteArray()); + + return to === 'hex' + ? eKey.toString('hex') + : eKey; + } + + d() { + if (this.keyIsPublic) + throw new Error('Can not get d component out of public key.'); + + return Buffer.from(this.privateKey.d.toByteArray()); + } + + isPrivate() { + return !this.keyIsPublic; + } + + isPublic() { + return this.keyIsPublic; + } + + // eslint-disable-next-line class-methods-use-this + size() { + return 2048; + } + + toPem() { + return this.keyIsPublic ? publicKeyToPem(this.publicKey) : privateKeyToPem(this.privateKey); + } +} From 61ada747f3978edc403f56e460537a8ffd4ad4e0 Mon Sep 17 00:00:00 2001 From: Vladislav Hristov Date: Fri, 1 Nov 2019 13:48:51 +0200 Subject: [PATCH 4/9] clean: remove modulus and exponent property from bankKeys() --- lib/orders/H004/response.js | 2 -- 1 file changed, 2 deletions(-) diff --git a/lib/orders/H004/response.js b/lib/orders/H004/response.js index 4e5a0b6..51f7d83 100644 --- a/lib/orders/H004/response.js +++ b/lib/orders/H004/response.js @@ -132,8 +132,6 @@ module.exports = (xml, keys) => ({ bankKeys[`bank${type}`] = { mod, exp, - modulus, - exponent, }; } From 59a281c8951bf81482da2318c42a6c1f308e613c Mon Sep 17 00:00:00 2001 From: Vladislav Hristov Date: Fri, 1 Nov 2019 13:49:33 +0200 Subject: [PATCH 5/9] feat: use new Key in Keys manager --- lib/keymanagers/Keys.js | 16 +++++++---- lib/keymanagers/_Keys.js | 59 +++++++++++++++++++++++++++++++++++++++ lib/keymanagers/keyRSA.js | 15 ++++++++-- 3 files changed, 82 insertions(+), 8 deletions(-) create mode 100644 lib/keymanagers/_Keys.js diff --git a/lib/keymanagers/Keys.js b/lib/keymanagers/Keys.js index fc110c7..1762642 100644 --- a/lib/keymanagers/Keys.js +++ b/lib/keymanagers/Keys.js @@ -1,8 +1,14 @@ 'use strict'; -const Key = require('./keyRSA'); +// const Key = require('./keyRSA'); +const Key = require('./Key'); -const keyOrNull = key => (key ? Key(key) : null); +const keyOrNull = (key) => { + if (key instanceof Key) + return key; + + return key ? new Key({ pem: key }) : null; +}; module.exports = class Keys { constructor({ @@ -25,15 +31,15 @@ module.exports = class Keys { const keys = {}; Object.keys({ A006: '', X002: '', E002: '' }).forEach((key) => { - keys[key] = Key().generate(); + keys[key] = Key.generate(); // Key().generate(); }); return new Keys(keys); } setBankKeys(bankKeys) { - this.keys.bankX002 = Key().importKey(bankKeys.bankX002); - this.keys.bankE002 = Key().importKey(bankKeys.bankE002); + this.keys.bankX002 = new Key(bankKeys.bankX002); // Key().importKey(bankKeys.bankX002); + this.keys.bankE002 = new Key(bankKeys.bankE002); // Key().importKey(bankKeys.bankE002); } a() { diff --git a/lib/keymanagers/_Keys.js b/lib/keymanagers/_Keys.js new file mode 100644 index 0000000..94fb1ce --- /dev/null +++ b/lib/keymanagers/_Keys.js @@ -0,0 +1,59 @@ +'use strict'; + +const Key = require('./keyRSA'); + +const keyOrNull = key => (key ? Key(key) : null); + +module.exports = class Keys { + constructor({ + A006, + E002, + X002, + bankX002, + bankE002, + }) { + this.keys = { + A006: keyOrNull(A006), + E002: keyOrNull(E002), + X002: keyOrNull(X002), + bankX002: keyOrNull(bankX002), + bankE002: keyOrNull(bankE002), + }; + console.log('debug'); + } + + static generate() { + const keys = {}; + + Object.keys({ A006: '', X002: '', E002: '' }).forEach((key) => { + keys[key] = Key().generate(); + }); + + return new Keys(keys); + } + + setBankKeys(bankKeys) { + this.keys.bankX002 = Key().importKey(bankKeys.bankX002); + this.keys.bankE002 = Key().importKey(bankKeys.bankE002); + } + + a() { + return this.keys.A006; + } + + e() { + return this.keys.E002; + } + + x() { + return this.keys.X002; + } + + bankX() { + return this.keys.bankX002; + } + + bankE() { + return this.keys.bankE002; + } +}; diff --git a/lib/keymanagers/keyRSA.js b/lib/keymanagers/keyRSA.js index d48d3c1..e359329 100644 --- a/lib/keymanagers/keyRSA.js +++ b/lib/keymanagers/keyRSA.js @@ -76,9 +76,18 @@ function rsaPublicKeyPem(modulus_b64, exponent_b64) { const BN = require('bn.js'); const NodeRSA = require('node-rsa'); -const { pki: { - rsa, publicKeyToPem, privateKeyToPem, publicKeyFromPem, privateKeyFromPem -}, jsbn: { BigInteger } } = require('node-forge'); +const { + pki: { + rsa, + publicKeyToPem, + privateKeyToPem, + publicKeyFromPem, + privateKeyFromPem, + }, + jsbn: { + BigInteger, + }, +} = require('node-forge'); const isKeyInstance = (obj) => { if (typeof obj !== 'object') From 836ec0ebf3a73b7612bc6351f0cfc326cb71470b Mon Sep 17 00:00:00 2001 From: Vladislav Hristov Date: Fri, 1 Nov 2019 13:49:59 +0200 Subject: [PATCH 6/9] fit(tests): use new Key in keys test --- test/keys.js | 28 ++++++++++++++++------------ 1 file changed, 16 insertions(+), 12 deletions(-) diff --git a/test/keys.js b/test/keys.js index c9736e1..b911f3d 100644 --- a/test/keys.js +++ b/test/keys.js @@ -2,16 +2,16 @@ const { assert } = require('chai'); const fixtures = require('./fixtures/keys'); -const Key = require('../lib/keymanagers/keyRSA'); +// const Key = require('../lib/keymanagers/keyRSA'); +const Key = require('../lib/keymanagers/Key'); const stripWhitespace = str => str.replace(/\s+/g, ''); describe('Keys management', () => { describe('generates brand new', () => { const keySize = 2048; - const newKey = Key().generate(keySize); - - // newKey.key = Key().generate(keySize); + // const newKey = Key().generate(keySize); + const newKey = Key.generate(); it('private key', () => { assert.isTrue(newKey.isPrivate()); @@ -29,14 +29,16 @@ describe('Keys management', () => { describe('that are strings', () => { const m = Buffer.from(mod.string, 'base64'); const e = Buffer.from(exp.string, 'base64'); - const newKey = Key().importKey({ + /* const newKey = Key().importKey({ mod: m, exp: e, modulus: mod.string, exponent: exp.string, - }); + }); */ + const newKey = new Key({ mod: m, exp: e }); it('and is really public', () => { assert.isTrue(newKey.isPublic()); }); + it('and has a propper mod in bytes', () => { assert.deepEqual([...newKey.n()], mod.bytes); }); @@ -49,9 +51,10 @@ describe('Keys management', () => { describe('that are bytes', () => { const m = Buffer.from(mod.bytes); const e = Buffer.from(exp.bytes); - const newKey = Key().importKey({ + /* const newKey = Key().importKey({ mod: m, exp: e, modulus: mod.string, exponent: exp.string, - }); + }); */ + const newKey = new Key({ mod: m, exp: e }); it('and is really public', () => { assert.isTrue(newKey.isPublic()); @@ -68,18 +71,19 @@ describe('Keys management', () => { }); describe('creates public key from pem string', () => { - const { pem, mod, exp } = fixtures.pblc.big; - const newKey = Key(pem); + const { pem } = fixtures.pblc.big; + // const newKey = Key(pem); + const newKey = new Key({ pem }); it('and is really public', () => { assert.isTrue(newKey.isPublic()); }); it('and has a propper(the same) pem string', () => { - newKey.pempem = { + /* newKey.pempem = { modulus: mod.string, exponent: exp.string, - }; + }; */ assert.equal(stripWhitespace(newKey.toPem()), stripWhitespace(pem)); }); }); From ce6cd02e580f541a36f0c6a1731558e796c21576 Mon Sep 17 00:00:00 2001 From: Vladislav Hristov Date: Fri, 1 Nov 2019 16:28:04 +0200 Subject: [PATCH 7/9] fit: BankLetter.js get key size --- lib/BankLetter.js | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/lib/BankLetter.js b/lib/BankLetter.js index 1221b22..5c77a3b 100644 --- a/lib/BankLetter.js +++ b/lib/BankLetter.js @@ -13,10 +13,8 @@ const registerHelpers = () => { handlebars.registerHelper('now', () => moment().format('HH:mm:ss')); handlebars.registerHelper('keyExponentBits', k => Buffer.byteLength(k.e()) * 8); - // handlebars.registerHelper('keyExponentBits', k => Buffer.byteLength(new BN(k.key.keyPair.e).toBuffer()) * 8); - handlebars.registerHelper('keyModulusBits', k => k.key.getKeySize()); - // return Buffer.byteLength(new BN(k.key.keyPair.e).toBuffer()) * 8; + handlebars.registerHelper('keyModulusBits', k => k.size()); handlebars.registerHelper('keyExponent', k => k.e('hex')); @@ -24,7 +22,6 @@ const registerHelpers = () => { handlebars.registerHelper('sha256', (k) => { const digest = Buffer.from(Crypto.digestPublicKey(k), 'base64').toString('HEX'); - // const digest = Buffer.from(k.publicDigest(), 'base64').toString('HEX'); return digest.toUpperCase().match(/.{1,2}/g).join(' '); }); }; From e8a80932e1d36155849010d2050ee194e09dff03 Mon Sep 17 00:00:00 2001 From: Vladislav Hristov Date: Fri, 1 Nov 2019 16:50:39 +0200 Subject: [PATCH 8/9] fit: key size is now calculated instead of hardcoded --- lib/keymanagers/Key.js | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/lib/keymanagers/Key.js b/lib/keymanagers/Key.js index 1f17e78..9a7f90b 100644 --- a/lib/keymanagers/Key.js +++ b/lib/keymanagers/Key.js @@ -106,9 +106,7 @@ module.exports = class Key { const key = this.keyIsPublic ? this.publicKey : this.privateKey; const eKey = Buffer.from(key.e.toByteArray()); - return to === 'hex' - ? eKey.toString('hex') - : eKey; + return to === 'hex' ? eKey.toString('hex') : eKey; } d() { @@ -128,7 +126,10 @@ module.exports = class Key { // eslint-disable-next-line class-methods-use-this size() { - return 2048; + const keyN = this.n('hex'); + const bn = new BigInteger(keyN, 16); + + return bn.bitLength(); } toPem() { From 104ec67f8c80c0e0a851d28e8a335b69895986a8 Mon Sep 17 00:00:00 2001 From: Vladislav Hristov Date: Fri, 1 Nov 2019 16:52:36 +0200 Subject: [PATCH 9/9] chore: add ; at the end of Key.js --- lib/keymanagers/Key.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/keymanagers/Key.js b/lib/keymanagers/Key.js index 9a7f90b..1fbb745 100644 --- a/lib/keymanagers/Key.js +++ b/lib/keymanagers/Key.js @@ -135,4 +135,4 @@ module.exports = class Key { toPem() { return this.keyIsPublic ? publicKeyToPem(this.publicKey) : privateKeyToPem(this.privateKey); } -} +};