forked from coolaj86/eckles.js
244 lines
6.6 KiB
JavaScript
244 lines
6.6 KiB
JavaScript
'use strict';
|
|
|
|
var Hex = {};
|
|
|
|
// 1.2.840.10045.3.1.7
|
|
// prime256v1 (ANSI X9.62 named elliptic curve)
|
|
var OBJ_ID_EC = '06 08 2A8648CE3D030107'.replace(/\s+/g, '').toLowerCase();
|
|
// 1.3.132.0.34
|
|
// secp384r1 (SECG (Certicom) named elliptic curve)
|
|
var OBJ_ID_EC_384 = '06 05 2B81040022'.replace(/\s+/g, '').toLowerCase();
|
|
|
|
|
|
// The one good thing that came from the b***kchain hysteria: good EC documentation
|
|
// https://davidederosa.com/basic-blockchain-programming/elliptic-curve-keys/
|
|
|
|
var PEM = {};
|
|
PEM._toUrlSafeBase64 = function (u8) {
|
|
//console.log('Len:', u8.byteLength);
|
|
return Buffer.from(u8).toString('base64')
|
|
.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
|
|
};
|
|
|
|
function toHex(ab) {
|
|
var hex = [];
|
|
var u8 = new Uint8Array(ab);
|
|
var size = u8.byteLength;
|
|
var i;
|
|
var h;
|
|
for (i = 0; i < size; i += 1) {
|
|
h = u8[i].toString(16);
|
|
if (2 === h.length) {
|
|
hex.push(h);
|
|
} else {
|
|
hex.push('0' + h);
|
|
}
|
|
}
|
|
return hex.join('').replace(/\s+/g, '').toLowerCase();
|
|
}
|
|
Hex.fromAB = toHex;
|
|
|
|
function parsePem(pem) {
|
|
var typ;
|
|
var pub;
|
|
var crv;
|
|
var der = Buffer.from(pem.split(/\n/).filter(function (line, i) {
|
|
if (0 === i) {
|
|
if (/ PUBLIC /.test(line)) {
|
|
pub = true;
|
|
} else if (/ PRIVATE /.test(line)) {
|
|
pub = false;
|
|
}
|
|
if (/ EC/.test(line)) {
|
|
typ = 'EC';
|
|
}
|
|
}
|
|
return !/---/.test(line);
|
|
}).join(''), 'base64');
|
|
|
|
if (!typ || 'EC' === typ) {
|
|
var hex = toHex(der);
|
|
if (-1 !== hex.indexOf(OBJ_ID_EC)) {
|
|
typ = 'EC';
|
|
crv = 'P-256';
|
|
} else if (-1 !== hex.indexOf(OBJ_ID_EC_384)) {
|
|
typ = 'EC';
|
|
crv = 'P-384';
|
|
} else {
|
|
// TODO support P-384 as well (but probably nothing else)
|
|
console.warn("unsupported ec curve");
|
|
}
|
|
}
|
|
|
|
return { typ: typ, pub: pub, der: der, crv: crv };
|
|
}
|
|
|
|
function parseEcOnlyPrivkey(u8, jwk) {
|
|
var index = 7;
|
|
var len = 32;
|
|
var olen = OBJ_ID_EC.length/2;
|
|
|
|
if ("P-384" === jwk.crv) {
|
|
olen = OBJ_ID_EC_384.length/2;
|
|
index = 8;
|
|
len = 48;
|
|
}
|
|
if (len !== u8[index - 1]) {
|
|
throw new Error("Unexpected bitlength " + len);
|
|
}
|
|
|
|
// private part is d
|
|
var d = u8.slice(index, index + len);
|
|
// compression bit index
|
|
var ci = index + len + 2 + olen + 2 + 3;
|
|
var c = u8[ci];
|
|
var x, y;
|
|
|
|
if (0x04 === c) {
|
|
y = u8.slice(ci + 1 + len, ci + 1 + len + len);
|
|
} else if (0x02 !== c) {
|
|
throw new Error("not a supported EC private key");
|
|
}
|
|
x = u8.slice(ci + 1, ci + 1 + len);
|
|
|
|
return {
|
|
kty: jwk.kty
|
|
, crv: jwk.crv
|
|
, d: PEM._toUrlSafeBase64(d)
|
|
//, dh: d
|
|
, x: PEM._toUrlSafeBase64(x)
|
|
//, xh: x
|
|
, y: PEM._toUrlSafeBase64(y)
|
|
//, yh: y
|
|
};
|
|
}
|
|
function parseEcPkcs8Privkey(u8, jwk) {
|
|
var index = 24 + (OBJ_ID_EC.length/2);
|
|
var len = 32;
|
|
if ("P-384" === jwk.crv) {
|
|
index = 24 + (OBJ_ID_EC_384.length/2) + 2;
|
|
len = 48;
|
|
}
|
|
|
|
//console.log(index, u8.slice(index));
|
|
if (0x04 !== u8[index]) {
|
|
//console.log(jwk);
|
|
throw new Error("privkey not found");
|
|
}
|
|
var d = u8.slice(index+2, index+2+len);
|
|
var ci = index+2+len+5;
|
|
var xi = ci+1;
|
|
var x = u8.slice(xi, xi + len);
|
|
var yi = xi+len;
|
|
var y;
|
|
if (0x04 === u8[ci]) {
|
|
y = u8.slice(yi, yi + len);
|
|
} else if (0x02 !== u8[ci]) {
|
|
throw new Error("invalid compression bit (expected 0x04 or 0x02)");
|
|
}
|
|
|
|
return {
|
|
kty: jwk.kty
|
|
, crv: jwk.crv
|
|
, d: PEM._toUrlSafeBase64(d)
|
|
//, dh: d
|
|
, x: PEM._toUrlSafeBase64(x)
|
|
//, xh: x
|
|
, y: PEM._toUrlSafeBase64(y)
|
|
//, yh: y
|
|
};
|
|
}
|
|
function parseEcPub(u8, jwk) {
|
|
var ci = 16 + OBJ_ID_EC.length/2;
|
|
var len = 32;
|
|
|
|
if ("P-384" === jwk.crv) {
|
|
ci = 16 + OBJ_ID_EC_384.length/2;
|
|
len = 48;
|
|
}
|
|
|
|
var c = u8[ci];
|
|
var xi = ci + 1;
|
|
var x = u8.slice(xi, xi + len);
|
|
var yi = xi + len;
|
|
var y;
|
|
if (0x04 === c) {
|
|
y = u8.slice(yi, yi + len);
|
|
} else if (0x02 !== c) {
|
|
throw new Error("not a supported EC private key");
|
|
}
|
|
|
|
return {
|
|
kty: jwk.kty
|
|
, crv: jwk.crv
|
|
, x: PEM._toUrlSafeBase64(x)
|
|
//, xh: x
|
|
, y: PEM._toUrlSafeBase64(y)
|
|
//, yh: y
|
|
};
|
|
}
|
|
|
|
/*global Promise*/
|
|
function parseEcPrivkey(opts) {
|
|
return Promise.resolve().then(function () {
|
|
if (!opts || !opts.pem) {
|
|
throw new Error("must pass { pem: pem }");
|
|
}
|
|
var pem = opts.pem;
|
|
var u8 = parsePem(pem).der;
|
|
var hex = toHex(u8);
|
|
var jwk = { kty: 'EC', crv: null, x: null, y: null };
|
|
|
|
//console.log();
|
|
if (-1 !== hex.indexOf(OBJ_ID_EC)) {
|
|
jwk.crv = "P-256";
|
|
|
|
// PKCS8
|
|
if (0x02 === u8[3] && 0x30 === u8[6] && 0x06 === u8[8]) {
|
|
//console.log("PKCS8", u8[3].toString(16), u8[6].toString(16), u8[8].toString(16));
|
|
return parseEcPkcs8Privkey(u8, jwk);
|
|
// EC-only
|
|
} else if (0x02 === u8[2] && 0x04 === u8[5] && 0xA0 === u8[39]) {
|
|
//console.log("EC---", u8[2].toString(16), u8[5].toString(16), u8[39].toString(16));
|
|
return parseEcOnlyPrivkey(u8, jwk);
|
|
// SPKI/PKIK (Public)
|
|
} else if (0x30 === u8[2] && 0x06 === u8[4] && 0x06 === u8[13]) {
|
|
//console.log("SPKI-", u8[2].toString(16), u8[4].toString(16), u8[13].toString(16));
|
|
return parseEcPub(u8, jwk);
|
|
// Error
|
|
} else {
|
|
//console.log("PKCS8", u8[3].toString(16), u8[6].toString(16), u8[8].toString(16));
|
|
//console.log("EC---", u8[2].toString(16), u8[5].toString(16), u8[39].toString(16));
|
|
//console.log("SPKI-", u8[2].toString(16), u8[4].toString(16), u8[13].toString(16));
|
|
throw new Error("unrecognized key format");
|
|
}
|
|
} else if (-1 !== hex.indexOf(OBJ_ID_EC_384)) {
|
|
jwk.crv = "P-384";
|
|
|
|
// PKCS8
|
|
if (0x02 === u8[3] && 0x30 === u8[6] && 0x06 === u8[8]) {
|
|
//console.log("PKCS8", u8[3].toString(16), u8[6].toString(16), u8[8].toString(16));
|
|
return parseEcPkcs8Privkey(u8, jwk);
|
|
// EC-only
|
|
} else if (0x02 === u8[3] && 0x04 === u8[6] && 0xA0 === u8[56]) {
|
|
//console.log("EC---", u8[3].toString(16), u8[6].toString(16), u8[56].toString(16));
|
|
return parseEcOnlyPrivkey(u8, jwk);
|
|
// SPKI/PKIK (Public)
|
|
} else if (0x30 === u8[2] && 0x06 === u8[4] && 0x06 === u8[13]) {
|
|
//console.log("SPKI-", u8[2].toString(16), u8[4].toString(16), u8[13].toString(16));
|
|
return parseEcPub(u8, jwk);
|
|
// Error
|
|
} else {
|
|
//console.log("PKCS8", u8[3].toString(16), u8[6].toString(16), u8[8].toString(16));
|
|
//console.log("EC---", u8[3].toString(16), u8[6].toString(16), u8[56].toString(16));
|
|
//console.log("SPKI-", u8[2].toString(16), u8[4].toString(16), u8[13].toString(16));
|
|
throw new Error("unrecognized key format");
|
|
}
|
|
} else {
|
|
throw new Error("Supported key types are P-256 and P-384");
|
|
}
|
|
});
|
|
}
|
|
|
|
module.exports.import = parseEcPrivkey;
|