290 lines
7.3 KiB
JavaScript
290 lines
7.3 KiB
JavaScript
// Copyright 2018 Joyent, Inc.
|
|
|
|
module.exports = {
|
|
read: read,
|
|
write: write
|
|
};
|
|
|
|
var assert = require('assert-plus');
|
|
var asn1 = require('asn1');
|
|
var crypto = require('crypto');
|
|
var Buffer = require('safer-buffer').Buffer;
|
|
var algs = require('../algs');
|
|
var utils = require('../utils');
|
|
var Key = require('../key');
|
|
var PrivateKey = require('../private-key');
|
|
|
|
var pkcs1 = require('./pkcs1');
|
|
var pkcs8 = require('./pkcs8');
|
|
var sshpriv = require('./ssh-private');
|
|
var rfc4253 = require('./rfc4253');
|
|
|
|
var errors = require('../errors');
|
|
|
|
var OID_PBES2 = '1.2.840.113549.1.5.13';
|
|
var OID_PBKDF2 = '1.2.840.113549.1.5.12';
|
|
|
|
var OID_TO_CIPHER = {
|
|
'1.2.840.113549.3.7': '3des-cbc',
|
|
'2.16.840.1.101.3.4.1.2': 'aes128-cbc',
|
|
'2.16.840.1.101.3.4.1.42': 'aes256-cbc'
|
|
};
|
|
var CIPHER_TO_OID = {};
|
|
Object.keys(OID_TO_CIPHER).forEach(function (k) {
|
|
CIPHER_TO_OID[OID_TO_CIPHER[k]] = k;
|
|
});
|
|
|
|
var OID_TO_HASH = {
|
|
'1.2.840.113549.2.7': 'sha1',
|
|
'1.2.840.113549.2.9': 'sha256',
|
|
'1.2.840.113549.2.11': 'sha512'
|
|
};
|
|
var HASH_TO_OID = {};
|
|
Object.keys(OID_TO_HASH).forEach(function (k) {
|
|
HASH_TO_OID[OID_TO_HASH[k]] = k;
|
|
});
|
|
|
|
/*
|
|
* For reading we support both PKCS#1 and PKCS#8. If we find a private key,
|
|
* we just take the public component of it and use that.
|
|
*/
|
|
function read(buf, options, forceType) {
|
|
var input = buf;
|
|
if (typeof (buf) !== 'string') {
|
|
assert.buffer(buf, 'buf');
|
|
buf = buf.toString('ascii');
|
|
}
|
|
|
|
var lines = buf.trim().split(/[\r\n]+/g);
|
|
|
|
var m;
|
|
var si = -1;
|
|
while (!m && si < lines.length) {
|
|
m = lines[++si].match(/*JSSTYLED*/
|
|
/[-]+[ ]*BEGIN ([A-Z0-9][A-Za-z0-9]+ )?(PUBLIC|PRIVATE) KEY[ ]*[-]+/);
|
|
}
|
|
assert.ok(m, 'invalid PEM header');
|
|
|
|
var m2;
|
|
var ei = lines.length;
|
|
while (!m2 && ei > 0) {
|
|
m2 = lines[--ei].match(/*JSSTYLED*/
|
|
/[-]+[ ]*END ([A-Z0-9][A-Za-z0-9]+ )?(PUBLIC|PRIVATE) KEY[ ]*[-]+/);
|
|
}
|
|
assert.ok(m2, 'invalid PEM footer');
|
|
|
|
/* Begin and end banners must match key type */
|
|
assert.equal(m[2], m2[2]);
|
|
var type = m[2].toLowerCase();
|
|
|
|
var alg;
|
|
if (m[1]) {
|
|
/* They also must match algorithms, if given */
|
|
assert.equal(m[1], m2[1], 'PEM header and footer mismatch');
|
|
alg = m[1].trim();
|
|
}
|
|
|
|
lines = lines.slice(si, ei + 1);
|
|
|
|
var headers = {};
|
|
while (true) {
|
|
lines = lines.slice(1);
|
|
m = lines[0].match(/*JSSTYLED*/
|
|
/^([A-Za-z0-9-]+): (.+)$/);
|
|
if (!m)
|
|
break;
|
|
headers[m[1].toLowerCase()] = m[2];
|
|
}
|
|
|
|
/* Chop off the first and last lines */
|
|
lines = lines.slice(0, -1).join('');
|
|
buf = Buffer.from(lines, 'base64');
|
|
|
|
var cipher, key, iv;
|
|
if (headers['proc-type']) {
|
|
var parts = headers['proc-type'].split(',');
|
|
if (parts[0] === '4' && parts[1] === 'ENCRYPTED') {
|
|
if (typeof (options.passphrase) === 'string') {
|
|
options.passphrase = Buffer.from(
|
|
options.passphrase, 'utf-8');
|
|
}
|
|
if (!Buffer.isBuffer(options.passphrase)) {
|
|
throw (new errors.KeyEncryptedError(
|
|
options.filename, 'PEM'));
|
|
} else {
|
|
parts = headers['dek-info'].split(',');
|
|
assert.ok(parts.length === 2);
|
|
cipher = parts[0].toLowerCase();
|
|
iv = Buffer.from(parts[1], 'hex');
|
|
key = utils.opensslKeyDeriv(cipher, iv,
|
|
options.passphrase, 1).key;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (alg && alg.toLowerCase() === 'encrypted') {
|
|
var eder = new asn1.BerReader(buf);
|
|
var pbesEnd;
|
|
eder.readSequence();
|
|
|
|
eder.readSequence();
|
|
pbesEnd = eder.offset + eder.length;
|
|
|
|
var method = eder.readOID();
|
|
if (method !== OID_PBES2) {
|
|
throw (new Error('Unsupported PEM/PKCS8 encryption ' +
|
|
'scheme: ' + method));
|
|
}
|
|
|
|
eder.readSequence(); /* PBES2-params */
|
|
|
|
eder.readSequence(); /* keyDerivationFunc */
|
|
var kdfEnd = eder.offset + eder.length;
|
|
var kdfOid = eder.readOID();
|
|
if (kdfOid !== OID_PBKDF2)
|
|
throw (new Error('Unsupported PBES2 KDF: ' + kdfOid));
|
|
eder.readSequence();
|
|
var salt = eder.readString(asn1.Ber.OctetString, true);
|
|
var iterations = eder.readInt();
|
|
var hashAlg = 'sha1';
|
|
if (eder.offset < kdfEnd) {
|
|
eder.readSequence();
|
|
var hashAlgOid = eder.readOID();
|
|
hashAlg = OID_TO_HASH[hashAlgOid];
|
|
if (hashAlg === undefined) {
|
|
throw (new Error('Unsupported PBKDF2 hash: ' +
|
|
hashAlgOid));
|
|
}
|
|
}
|
|
eder._offset = kdfEnd;
|
|
|
|
eder.readSequence(); /* encryptionScheme */
|
|
var cipherOid = eder.readOID();
|
|
cipher = OID_TO_CIPHER[cipherOid];
|
|
if (cipher === undefined) {
|
|
throw (new Error('Unsupported PBES2 cipher: ' +
|
|
cipherOid));
|
|
}
|
|
iv = eder.readString(asn1.Ber.OctetString, true);
|
|
|
|
eder._offset = pbesEnd;
|
|
buf = eder.readString(asn1.Ber.OctetString, true);
|
|
|
|
if (typeof (options.passphrase) === 'string') {
|
|
options.passphrase = Buffer.from(
|
|
options.passphrase, 'utf-8');
|
|
}
|
|
if (!Buffer.isBuffer(options.passphrase)) {
|
|
throw (new errors.KeyEncryptedError(
|
|
options.filename, 'PEM'));
|
|
}
|
|
|
|
var cinfo = utils.opensshCipherInfo(cipher);
|
|
|
|
cipher = cinfo.opensslName;
|
|
key = utils.pbkdf2(hashAlg, salt, iterations, cinfo.keySize,
|
|
options.passphrase);
|
|
alg = undefined;
|
|
}
|
|
|
|
if (cipher && key && iv) {
|
|
var cipherStream = crypto.createDecipheriv(cipher, key, iv);
|
|
var chunk, chunks = [];
|
|
cipherStream.once('error', function (e) {
|
|
if (e.toString().indexOf('bad decrypt') !== -1) {
|
|
throw (new Error('Incorrect passphrase ' +
|
|
'supplied, could not decrypt key'));
|
|
}
|
|
throw (e);
|
|
});
|
|
cipherStream.write(buf);
|
|
cipherStream.end();
|
|
while ((chunk = cipherStream.read()) !== null)
|
|
chunks.push(chunk);
|
|
buf = Buffer.concat(chunks);
|
|
}
|
|
|
|
/* The new OpenSSH internal format abuses PEM headers */
|
|
if (alg && alg.toLowerCase() === 'openssh')
|
|
return (sshpriv.readSSHPrivate(type, buf, options));
|
|
if (alg && alg.toLowerCase() === 'ssh2')
|
|
return (rfc4253.readType(type, buf, options));
|
|
|
|
var der = new asn1.BerReader(buf);
|
|
der.originalInput = input;
|
|
|
|
/*
|
|
* All of the PEM file types start with a sequence tag, so chop it
|
|
* off here
|
|
*/
|
|
der.readSequence();
|
|
|
|
/* PKCS#1 type keys name an algorithm in the banner explicitly */
|
|
if (alg) {
|
|
if (forceType)
|
|
assert.strictEqual(forceType, 'pkcs1');
|
|
return (pkcs1.readPkcs1(alg, type, der));
|
|
} else {
|
|
if (forceType)
|
|
assert.strictEqual(forceType, 'pkcs8');
|
|
return (pkcs8.readPkcs8(alg, type, der));
|
|
}
|
|
}
|
|
|
|
function write(key, options, type) {
|
|
assert.object(key);
|
|
|
|
var alg = {
|
|
'ecdsa': 'EC',
|
|
'rsa': 'RSA',
|
|
'dsa': 'DSA',
|
|
'ed25519': 'EdDSA'
|
|
}[key.type];
|
|
var header;
|
|
|
|
var der = new asn1.BerWriter();
|
|
|
|
if (PrivateKey.isPrivateKey(key)) {
|
|
if (type && type === 'pkcs8') {
|
|
header = 'PRIVATE KEY';
|
|
pkcs8.writePkcs8(der, key);
|
|
} else {
|
|
if (type)
|
|
assert.strictEqual(type, 'pkcs1');
|
|
header = alg + ' PRIVATE KEY';
|
|
pkcs1.writePkcs1(der, key);
|
|
}
|
|
|
|
} else if (Key.isKey(key)) {
|
|
if (type && type === 'pkcs1') {
|
|
header = alg + ' PUBLIC KEY';
|
|
pkcs1.writePkcs1(der, key);
|
|
} else {
|
|
if (type)
|
|
assert.strictEqual(type, 'pkcs8');
|
|
header = 'PUBLIC KEY';
|
|
pkcs8.writePkcs8(der, key);
|
|
}
|
|
|
|
} else {
|
|
throw (new Error('key is not a Key or PrivateKey'));
|
|
}
|
|
|
|
var tmp = der.buffer.toString('base64');
|
|
var len = tmp.length + (tmp.length / 64) +
|
|
18 + 16 + header.length*2 + 10;
|
|
var buf = Buffer.alloc(len);
|
|
var o = 0;
|
|
o += buf.write('-----BEGIN ' + header + '-----\n', o);
|
|
for (var i = 0; i < tmp.length; ) {
|
|
var limit = i + 64;
|
|
if (limit > tmp.length)
|
|
limit = tmp.length;
|
|
o += buf.write(tmp.slice(i, limit), o);
|
|
buf[o++] = 10;
|
|
i = limit;
|
|
}
|
|
o += buf.write('-----END ' + header + '-----\n', o);
|
|
|
|
return (buf.slice(0, o));
|
|
}
|