diff --git a/lib/BankLetter.js b/lib/BankLetter.js
index 400766e..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,8 +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(' ');
});
};
diff --git a/lib/keymanagers/Key.js b/lib/keymanagers/Key.js
new file mode 100644
index 0000000..1fbb745
--- /dev/null
+++ b/lib/keymanagers/Key.js
@@ -0,0 +1,138 @@
+'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() {
+ const keyN = this.n('hex');
+ const bn = new BigInteger(keyN, 16);
+
+ return bn.bitLength();
+ }
+
+ toPem() {
+ return this.keyIsPublic ? publicKeyToPem(this.publicKey) : privateKeyToPem(this.privateKey);
+ }
+};
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 a3c59a8..e359329 100644
--- a/lib/keymanagers/keyRSA.js
+++ b/lib/keymanagers/keyRSA.js
@@ -1,49 +1,228 @@
'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 e6dc2f7..b82a9ab 100644
--- a/lib/orders/H004/response.js
+++ b/lib/orders/H004/response.js
@@ -127,10 +127,12 @@ module.exports = (xml, keys) => ({
const modulus = xpath.select(".//*[local-name(.)='Modulus']", keyNodes[i])[0].textContent;
const exponent = xpath.select(".//*[local-name(.)='Exponent']", keyNodes[i])[0].textContent;
- const mod = new BN(Buffer.from(modulus, 'base64'), 2).toBuffer();
- 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,
+ };
}
return bankKeys;
diff --git a/package.json b/package.json
index f7b6486..d40560d 100644
--- a/package.json
+++ b/package.json
@@ -34,6 +34,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..b911f3d
--- /dev/null
+++ b/test/keys.js
@@ -0,0 +1,90 @@
+'use strict';
+
+const { assert } = require('chai');
+const fixtures = require('./fixtures/keys');
+// 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);
+ const newKey = Key.generate();
+
+ 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,
+ }); */
+ 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);
+ });
+
+ 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,
+ }); */
+ const newKey = new Key({ mod: m, exp: e });
+
+ 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 } = 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 = {
+ modulus: mod.string,
+ exponent: exp.string,
+ }; */
+ assert.equal(stripWhitespace(newKey.toPem()), stripWhitespace(pem));
+ });
+ });
+});