wip: monorepro

packages/ebics-client/lib/keymanagers/Keys.js

@@ -0,0 +1,58 @@
+'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),
+		};
+	}
+
+	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;
+	}
+};

packages/ebics-client/lib/keymanagers/KeysManager.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const crypto = require('crypto');
+
+const Keys = require('./Keys');
+
+const encrypt = (data, algorithm, passphrase) => {
+	const cipher = crypto.createCipher(algorithm, passphrase);
+	const encrypted = cipher.update(data, 'utf8', 'hex') + cipher.final('hex');
+
+	return Buffer.from(encrypted).toString('base64');
+};
+const decrypt = (data, algorithm, passphrase) => {
+	data = (Buffer.from(data, 'base64')).toString();
+
+	const decipher = crypto.createDecipher(algorithm, passphrase);
+	const decrypted = decipher.update(data, 'hex', 'utf8') + decipher.final('utf8');
+
+	return decrypted;
+};
+
+module.exports = (keysStorage, passphrase, algorithm = 'aes-256-cbc') => {
+	const storage = keysStorage;
+	const pass = passphrase;
+	const algo = algorithm;
+	// const createIfNone = createIfNone;
+
+	return {
+		generate(save = true) {
+			const keys = Keys.generate();
+
+			if (save) {
+				this.write(keys);
+
+				return this;
+			}
+
+			return keys;
+		},
+
+		write(keysObject) {
+			keysObject = keysObject.keys;
+
+			Object.keys(keysObject).map((key) => {
+				keysObject[key] = keysObject[key] === null ? null : keysObject[key].toPem();
+
+				return key;
+			});
+
+			storage.write(encrypt(JSON.stringify(keysObject), algo, pass));
+
+			return this;
+		},
+
+		setBankKeys(bankKeys) {
+			const keys = this.keys();
+
+			keys.setBankKeys(bankKeys);
+			this.write(keys);
+		},
+
+		keys() {
+			const keysString = storage.read();
+
+			return new Keys(JSON.parse(decrypt(keysString, algo, pass)));
+		},
+	};
+};

packages/ebics-client/lib/keymanagers/defaultKeyEncryptor.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const crypto = require('crypto');
+
+const encrypt = (data, algorithm, passphrase) => {
+	const cipher = crypto.createCipher(algorithm, passphrase);
+	const encrypted = cipher.update(data, 'utf8', 'hex') + cipher.final('hex');
+	return Buffer.from(encrypted).toString('base64');
+};
+const decrypt = (data, algorithm, passphrase) => {
+	data = (Buffer.from(data, 'base64')).toString();
+	const decipher = crypto.createDecipher(algorithm, passphrase);
+	const decrypted = decipher.update(data, 'hex', 'utf8') + decipher.final('utf8');
+
+	return decrypted;
+};
+
+module.exports = ({
+	passphrase,
+	algorithm = 'aes-256-cbc',
+}) => ({
+	encrypt: data => encrypt(data, algorithm, passphrase),
+	decrypt: data => decrypt(data, algorithm, passphrase),
+});

packages/ebics-client/lib/keymanagers/keyRSA.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const BN = require('bn.js');
+const NodeRSA = require('node-rsa');
+
+const keyOrNull = (encodedKey) => {
+	if (encodedKey === null) return new NodeRSA();
+
+	return (encodedKey instanceof NodeRSA) ? encodedKey : new NodeRSA(encodedKey);
+};
+
+module.exports = encodedKey => ({
+	key: keyOrNull(encodedKey),
+
+	generate(keySize = 2048) {
+		return new NodeRSA({ b: keySize });
+	},
+
+	importKey({ mod, exp }) {
+		this.key = new NodeRSA();
+		this.key.importKey({ n: mod, e: exp }, 'components-public');
+
+		return this;
+	},
+
+	n(to = 'buff') {
+		const keyN = Buffer.from(this.key.exportKey('components-public').n);
+
+		return to === 'hex'
+			? keyN.toString('hex', 1)
+			: keyN;
+	},
+
+	e(to = 'buff') {
+		const eKey = new BN(this.key.exportKey('components-public').e).toBuffer();
+
+		return to === 'hex'
+			? eKey.toString('hex')
+			: eKey;
+	},
+
+	d() {
+		return this.key.keyPair.d.toBuffer();
+	},
+
+	toPem() {
+		return this.key.isPrivate() ? this.key.exportKey('pkcs1-private-pem') : this.key.exportKey('pkcs8-public-pem');
+	},
+});