forked from root/acme.js
228 lines
5.6 KiB
JavaScript
228 lines
5.6 KiB
JavaScript
/*global Promise*/
|
|
(function(exports) {
|
|
'use strict';
|
|
|
|
var EC = (exports.Eckles = {});
|
|
var x509 = exports.x509;
|
|
if ('undefined' !== typeof module) {
|
|
module.exports = EC;
|
|
}
|
|
var PEM = exports.PEM;
|
|
var SSH = exports.SSH;
|
|
var Enc = {};
|
|
var textEncoder = new TextEncoder();
|
|
|
|
EC._stance =
|
|
"We take the stance that if you're knowledgeable enough to" +
|
|
" properly and securely use non-standard crypto then you shouldn't need Bluecrypt anyway.";
|
|
EC._universal =
|
|
'Bluecrypt only supports crypto with standard cross-browser and cross-platform support.';
|
|
EC.generate = function(opts) {
|
|
var wcOpts = {};
|
|
if (!opts) {
|
|
opts = {};
|
|
}
|
|
if (!opts.kty) {
|
|
opts.kty = 'EC';
|
|
}
|
|
|
|
// ECDSA has only the P curves and an associated bitlength
|
|
wcOpts.name = 'ECDSA';
|
|
if (!opts.namedCurve) {
|
|
opts.namedCurve = 'P-256';
|
|
}
|
|
wcOpts.namedCurve = opts.namedCurve; // true for supported curves
|
|
if (/256/.test(wcOpts.namedCurve)) {
|
|
wcOpts.namedCurve = 'P-256';
|
|
wcOpts.hash = { name: 'SHA-256' };
|
|
} else if (/384/.test(wcOpts.namedCurve)) {
|
|
wcOpts.namedCurve = 'P-384';
|
|
wcOpts.hash = { name: 'SHA-384' };
|
|
} else {
|
|
return Promise.Reject(
|
|
new Error(
|
|
"'" +
|
|
wcOpts.namedCurve +
|
|
"' is not an NIST approved ECDSA namedCurve. " +
|
|
" Please choose either 'P-256' or 'P-384'. " +
|
|
EC._stance
|
|
)
|
|
);
|
|
}
|
|
|
|
var extractable = true;
|
|
return window.crypto.subtle
|
|
.generateKey(wcOpts, extractable, ['sign', 'verify'])
|
|
.then(function(result) {
|
|
return window.crypto.subtle
|
|
.exportKey('jwk', result.privateKey)
|
|
.then(function(privJwk) {
|
|
privJwk.key_ops = undefined;
|
|
privJwk.ext = undefined;
|
|
return {
|
|
private: privJwk,
|
|
public: EC.neuter({ jwk: privJwk })
|
|
};
|
|
});
|
|
});
|
|
};
|
|
|
|
EC.export = function(opts) {
|
|
return Promise.resolve().then(function() {
|
|
if (!opts || !opts.jwk || 'object' !== typeof opts.jwk) {
|
|
throw new Error('must pass { jwk: jwk } as a JSON object');
|
|
}
|
|
var jwk = JSON.parse(JSON.stringify(opts.jwk));
|
|
var format = opts.format;
|
|
if (
|
|
opts.public ||
|
|
-1 !== ['spki', 'pkix', 'ssh', 'rfc4716'].indexOf(format)
|
|
) {
|
|
jwk.d = null;
|
|
}
|
|
if ('EC' !== jwk.kty) {
|
|
throw new Error("options.jwk.kty must be 'EC' for EC keys");
|
|
}
|
|
if (!jwk.d) {
|
|
if (!format || -1 !== ['spki', 'pkix'].indexOf(format)) {
|
|
format = 'spki';
|
|
} else if (-1 !== ['ssh', 'rfc4716'].indexOf(format)) {
|
|
format = 'ssh';
|
|
} else {
|
|
throw new Error(
|
|
"options.format must be 'spki' or 'ssh' for public EC keys, not (" +
|
|
typeof format +
|
|
') ' +
|
|
format
|
|
);
|
|
}
|
|
} else {
|
|
if (!format || 'sec1' === format) {
|
|
format = 'sec1';
|
|
} else if ('pkcs8' !== format) {
|
|
throw new Error(
|
|
"options.format must be 'sec1' or 'pkcs8' for private EC keys, not '" +
|
|
format +
|
|
"'"
|
|
);
|
|
}
|
|
}
|
|
if (-1 === ['P-256', 'P-384'].indexOf(jwk.crv)) {
|
|
throw new Error(
|
|
"options.jwk.crv must be either P-256 or P-384 for EC keys, not '" +
|
|
jwk.crv +
|
|
"'"
|
|
);
|
|
}
|
|
if (!jwk.y) {
|
|
throw new Error(
|
|
'options.jwk.y must be a urlsafe base64-encoded either P-256 or P-384'
|
|
);
|
|
}
|
|
|
|
if ('sec1' === format) {
|
|
return PEM.packBlock({
|
|
type: 'EC PRIVATE KEY',
|
|
bytes: x509.packSec1(jwk)
|
|
});
|
|
} else if ('pkcs8' === format) {
|
|
return PEM.packBlock({
|
|
type: 'PRIVATE KEY',
|
|
bytes: x509.packPkcs8(jwk)
|
|
});
|
|
} else if (-1 !== ['spki', 'pkix'].indexOf(format)) {
|
|
return PEM.packBlock({
|
|
type: 'PUBLIC KEY',
|
|
bytes: x509.packSpki(jwk)
|
|
});
|
|
} else if (-1 !== ['ssh', 'rfc4716'].indexOf(format)) {
|
|
return SSH.packSsh(jwk);
|
|
} else {
|
|
throw new Error(
|
|
'Sanity Error: reached unreachable code block with format: ' +
|
|
format
|
|
);
|
|
}
|
|
});
|
|
};
|
|
EC.pack = function(opts) {
|
|
return Promise.resolve().then(function() {
|
|
return EC.exportSync(opts);
|
|
});
|
|
};
|
|
|
|
// Chopping off the private parts is now part of the public API.
|
|
// I thought it sounded a little too crude at first, but it really is the best name in every possible way.
|
|
EC.neuter = function(opts) {
|
|
// trying to find the best balance of an immutable copy with custom attributes
|
|
var jwk = {};
|
|
Object.keys(opts.jwk).forEach(function(k) {
|
|
if ('undefined' === typeof opts.jwk[k]) {
|
|
return;
|
|
}
|
|
// ignore EC private parts
|
|
if ('d' === k) {
|
|
return;
|
|
}
|
|
jwk[k] = JSON.parse(JSON.stringify(opts.jwk[k]));
|
|
});
|
|
return jwk;
|
|
};
|
|
|
|
// https://stackoverflow.com/questions/42588786/how-to-fingerprint-a-jwk
|
|
EC.__thumbprint = function(jwk) {
|
|
// Use the same entropy for SHA as for key
|
|
var alg = 'SHA-256';
|
|
if (/384/.test(jwk.crv)) {
|
|
alg = 'SHA-384';
|
|
}
|
|
return window.crypto.subtle
|
|
.digest(
|
|
{ name: alg },
|
|
textEncoder.encode(
|
|
'{"crv":"' +
|
|
jwk.crv +
|
|
'","kty":"EC","x":"' +
|
|
jwk.x +
|
|
'","y":"' +
|
|
jwk.y +
|
|
'"}'
|
|
)
|
|
)
|
|
.then(function(hash) {
|
|
return Enc.bufToUrlBase64(new Uint8Array(hash));
|
|
});
|
|
};
|
|
|
|
EC.thumbprint = function(opts) {
|
|
return Promise.resolve().then(function() {
|
|
var jwk;
|
|
if ('EC' === opts.kty) {
|
|
jwk = opts;
|
|
} else if (opts.jwk) {
|
|
jwk = opts.jwk;
|
|
} else {
|
|
return EC.import(opts).then(function(jwk) {
|
|
return EC.__thumbprint(jwk);
|
|
});
|
|
}
|
|
return EC.__thumbprint(jwk);
|
|
});
|
|
};
|
|
|
|
Enc.bufToUrlBase64 = function(u8) {
|
|
return Enc.bufToBase64(u8)
|
|
.replace(/\+/g, '-')
|
|
.replace(/\//g, '_')
|
|
.replace(/=/g, '');
|
|
};
|
|
|
|
Enc.bufToBase64 = function(u8) {
|
|
var bin = '';
|
|
u8.forEach(function(i) {
|
|
bin += String.fromCharCode(i);
|
|
});
|
|
return btoa(bin);
|
|
};
|
|
})('undefined' !== typeof module ? module.exports : window);
|