wip: migrate to node-forge

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;
+		*/
+		},
+	};
+};