120 lines
3.2 KiB
JavaScript
120 lines
3.2 KiB
JavaScript
'use strict';
|
|
|
|
function binstrToB64Url(binstr) {
|
|
return new Buffer(binstr, 'binary').toString('base64')
|
|
.replace(/[+]/g, "-").replace(/\//g, "_").replace(/=/g,"");
|
|
}
|
|
|
|
var extrac = module.exports = {
|
|
//
|
|
// internals
|
|
//
|
|
_forgeToPrivateJwk: function (keypair) {
|
|
var k = keypair._forge;
|
|
|
|
return {
|
|
kty: "RSA"
|
|
, n: binstrToB64Url(k.n.toByteArray())
|
|
, e: binstrToB64Url(k.e.toByteArray())
|
|
, d: binstrToB64Url(k.d.toByteArray())
|
|
, p: binstrToB64Url(k.p.toByteArray())
|
|
, q: binstrToB64Url(k.q.toByteArray())
|
|
, dp: binstrToB64Url(k.dP.toByteArray())
|
|
, dq: binstrToB64Url(k.dQ.toByteArray())
|
|
, qi: binstrToB64Url(k.qInv.toByteArray())
|
|
};
|
|
}
|
|
, _forgeToPublicJwk: function (keypair) {
|
|
var k = keypair._forge || keypair._forgePublic;
|
|
return {
|
|
kty: "RSA"
|
|
, n: binstrToB64Url(k.n.toByteArray())
|
|
, e: binstrToB64Url(k.e.toByteArray())
|
|
};
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Import Forge
|
|
//
|
|
, _forgeImportJwk: require('./rsa-forge')._forgeImportJwk
|
|
, _forgeImportPublicJwk: require('./rsa-forge')._forgeImportPublicJwk
|
|
, _forgeImportPem: require('./rsa-forge')._forgeImportPem
|
|
, _forgeImportPublicPem: require('./rsa-forge')._forgeImportPublicPem
|
|
, importForge: function (keypair) {
|
|
extrac._forgeImportJwk(keypair);
|
|
if (keypair.privateKeyPem) {
|
|
extrac._forgeImportPem(keypair);
|
|
}
|
|
if (keypair.publicKeyPem) {
|
|
extrac._forgeImportPublicPem(keypair);
|
|
}
|
|
return keypair;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Export JWK
|
|
//
|
|
, exportPrivateJwk: function (keypair) {
|
|
var hasUrsaPrivate = keypair._ursa && true;
|
|
var hasPrivatePem = keypair.privateKeyPem && true;
|
|
var hasForgePrivate = keypair._forge && true;
|
|
|
|
if (keypair.privateKeyJwk) {
|
|
return keypair.privateKeyJwk;
|
|
}
|
|
|
|
if (!hasForgePrivate) {
|
|
if (hasUrsaPrivate && !hasPrivatePem) {
|
|
keypair.privateKeyPem = keypair._ursa.toPrivatePem().toString('ascii');
|
|
}
|
|
|
|
if (keypair.privateKeyPem) {
|
|
extrac._forgeImportPem(keypair);
|
|
}
|
|
}
|
|
|
|
if (keypair._forge) {
|
|
return extrac._forgeToPrivateJwk(keypair);
|
|
}
|
|
|
|
throw new Error("None of privateKeyPem, _ursa, _forge, or privateKeyJwk found. No way to export private key Jwk");
|
|
}
|
|
, exportPublicJwk: function (keypair) {
|
|
var hasUrsaPublic = (keypair._ursa || keypair._ursaPublic) && true;
|
|
var hasPublicPem = (keypair.privateKeyPem || keypair.publicKeyPem) && true;
|
|
var hasForgePublic = keypair._forge && true;
|
|
|
|
if (keypair.publicKeyJwk) {
|
|
return keypair.publicKeyJwk;
|
|
}
|
|
|
|
if (keypair.privateKeyJwk) {
|
|
return {
|
|
kty: 'RSA'
|
|
, n: keypair.privateKeyJwk.n
|
|
, e: keypair.privateKeyJwk.e
|
|
};
|
|
}
|
|
|
|
if (!hasForgePublic) {
|
|
if (hasUrsaPublic && !hasPublicPem) {
|
|
keypair.publicKeyPem = (keypair._ursa || keypair._ursaPublic).toPublicPem().toString('ascii');
|
|
}
|
|
|
|
if (keypair.publicKeyPem) {
|
|
extrac._forgeImportPublicPem(keypair);
|
|
}
|
|
}
|
|
|
|
if (keypair._forge || keypair._forgePublic) {
|
|
return extrac._forgeToPublicJwk(keypair);
|
|
}
|
|
|
|
throw new Error("None of publicKeyPem privateKeyPem, _ursa, _forge, publicKeyJwk, or privateKeyJwk found. No way to export private key Jwk");
|
|
}
|
|
};
|