pdf-creator-node 1.4.0 → 1.4.1

package/example/node_modules/sshpk/lib/private-key.js

@@ -1,246 +0,0 @@
-// Copyright 2017 Joyent, Inc.
-
-module.exports = PrivateKey;
-
-var assert = require('assert-plus');
-var Buffer = require('safer-buffer').Buffer;
-var algs = require('./algs');
-var crypto = require('crypto');
-var Fingerprint = require('./fingerprint');
-var Signature = require('./signature');
-var errs = require('./errors');
-var util = require('util');
-var utils = require('./utils');
-var dhe = require('./dhe');
-var generateECDSA = dhe.generateECDSA;
-var generateED25519 = dhe.generateED25519;
-var edCompat = require('./ed-compat');
-var nacl = require('tweetnacl');
-
-var Key = require('./key');
-
-var InvalidAlgorithmError = errs.InvalidAlgorithmError;
-var KeyParseError = errs.KeyParseError;
-var KeyEncryptedError = errs.KeyEncryptedError;
-
-var formats = {};
-formats['auto'] = require('./formats/auto');
-formats['pem'] = require('./formats/pem');
-formats['pkcs1'] = require('./formats/pkcs1');
-formats['pkcs8'] = require('./formats/pkcs8');
-formats['rfc4253'] = require('./formats/rfc4253');
-formats['ssh-private'] = require('./formats/ssh-private');
-formats['openssh'] = formats['ssh-private'];
-formats['ssh'] = formats['ssh-private'];
-formats['dnssec'] = require('./formats/dnssec');
-
-function PrivateKey(opts) {
-	assert.object(opts, 'options');
-	Key.call(this, opts);
-
-	this._pubCache = undefined;
-}
-util.inherits(PrivateKey, Key);
-
-PrivateKey.formats = formats;
-
-PrivateKey.prototype.toBuffer = function (format, options) {
-	if (format === undefined)
-		format = 'pkcs1';
-	assert.string(format, 'format');
-	assert.object(formats[format], 'formats[format]');
-	assert.optionalObject(options, 'options');
-
-	return (formats[format].write(this, options));
-};
-
-PrivateKey.prototype.hash = function (algo, type) {
-	return (this.toPublic().hash(algo, type));
-};
-
-PrivateKey.prototype.fingerprint = function (algo, type) {
-	return (this.toPublic().fingerprint(algo, type));
-};
-
-PrivateKey.prototype.toPublic = function () {
-	if (this._pubCache)
-		return (this._pubCache);
-
-	var algInfo = algs.info[this.type];
-	var pubParts = [];
-	for (var i = 0; i < algInfo.parts.length; ++i) {
-		var p = algInfo.parts[i];
-		pubParts.push(this.part[p]);
-	}
-
-	this._pubCache = new Key({
-		type: this.type,
-		source: this,
-		parts: pubParts
-	});
-	if (this.comment)
-		this._pubCache.comment = this.comment;
-	return (this._pubCache);
-};
-
-PrivateKey.prototype.derive = function (newType) {
-	assert.string(newType, 'type');
-	var priv, pub, pair;
-
-	if (this.type === 'ed25519' && newType === 'curve25519') {
-		priv = this.part.k.data;
-		if (priv[0] === 0x00)
-			priv = priv.slice(1);
-
-		pair = nacl.box.keyPair.fromSecretKey(new Uint8Array(priv));
-		pub = Buffer.from(pair.publicKey);
-
-		return (new PrivateKey({
-			type: 'curve25519',
-			parts: [
-				{ name: 'A', data: utils.mpNormalize(pub) },
-				{ name: 'k', data: utils.mpNormalize(priv) }
-			]
-		}));
-	} else if (this.type === 'curve25519' && newType === 'ed25519') {
-		priv = this.part.k.data;
-		if (priv[0] === 0x00)
-			priv = priv.slice(1);
-
-		pair = nacl.sign.keyPair.fromSeed(new Uint8Array(priv));
-		pub = Buffer.from(pair.publicKey);
-
-		return (new PrivateKey({
-			type: 'ed25519',
-			parts: [
-				{ name: 'A', data: utils.mpNormalize(pub) },
-				{ name: 'k', data: utils.mpNormalize(priv) }
-			]
-		}));
-	}
-	throw (new Error('Key derivation not supported from ' + this.type +
-	    ' to ' + newType));
-};
-
-PrivateKey.prototype.createVerify = function (hashAlgo) {
-	return (this.toPublic().createVerify(hashAlgo));
-};
-
-PrivateKey.prototype.createSign = function (hashAlgo) {
-	if (hashAlgo === undefined)
-		hashAlgo = this.defaultHashAlgorithm();
-	assert.string(hashAlgo, 'hash algorithm');
-
-	/* ED25519 is not supported by OpenSSL, use a javascript impl. */
-	if (this.type === 'ed25519' && edCompat !== undefined)
-		return (new edCompat.Signer(this, hashAlgo));
-	if (this.type === 'curve25519')
-		throw (new Error('Curve25519 keys are not suitable for ' +
-		    'signing or verification'));
-
-	var v, nm, err;
-	try {
-		nm = hashAlgo.toUpperCase();
-		v = crypto.createSign(nm);
-	} catch (e) {
-		err = e;
-	}
-	if (v === undefined || (err instanceof Error &&
-	    err.message.match(/Unknown message digest/))) {
-		nm = 'RSA-';
-		nm += hashAlgo.toUpperCase();
-		v = crypto.createSign(nm);
-	}
-	assert.ok(v, 'failed to create verifier');
-	var oldSign = v.sign.bind(v);
-	var key = this.toBuffer('pkcs1');
-	var type = this.type;
-	var curve = this.curve;
-	v.sign = function () {
-		var sig = oldSign(key);
-		if (typeof (sig) === 'string')
-			sig = Buffer.from(sig, 'binary');
-		sig = Signature.parse(sig, type, 'asn1');
-		sig.hashAlgorithm = hashAlgo;
-		sig.curve = curve;
-		return (sig);
-	};
-	return (v);
-};
-
-PrivateKey.parse = function (data, format, options) {
-	if (typeof (data) !== 'string')
-		assert.buffer(data, 'data');
-	if (format === undefined)
-		format = 'auto';
-	assert.string(format, 'format');
-	if (typeof (options) === 'string')
-		options = { filename: options };
-	assert.optionalObject(options, 'options');
-	if (options === undefined)
-		options = {};
-	assert.optionalString(options.filename, 'options.filename');
-	if (options.filename === undefined)
-		options.filename = '(unnamed)';
-
-	assert.object(formats[format], 'formats[format]');
-
-	try {
-		var k = formats[format].read(data, options);
-		assert.ok(k instanceof PrivateKey, 'key is not a private key');
-		if (!k.comment)
-			k.comment = options.filename;
-		return (k);
-	} catch (e) {
-		if (e.name === 'KeyEncryptedError')
-			throw (e);
-		throw (new KeyParseError(options.filename, format, e));
-	}
-};
-
-PrivateKey.isPrivateKey = function (obj, ver) {
-	return (utils.isCompatible(obj, PrivateKey, ver));
-};
-
-PrivateKey.generate = function (type, options) {
-	if (options === undefined)
-		options = {};
-	assert.object(options, 'options');
-
-	switch (type) {
-	case 'ecdsa':
-		if (options.curve === undefined)
-			options.curve = 'nistp256';
-		assert.string(options.curve, 'options.curve');
-		return (generateECDSA(options.curve));
-	case 'ed25519':
-		return (generateED25519());
-	default:
-		throw (new Error('Key generation not supported with key ' +
-		    'type "' + type + '"'));
-	}
-};
-
-/*
- * API versions for PrivateKey:
- * [1,0] -- initial ver
- * [1,1] -- added auto, pkcs[18], openssh/ssh-private formats
- * [1,2] -- added defaultHashAlgorithm
- * [1,3] -- added derive, ed, createDH
- * [1,4] -- first tagged version
- * [1,5] -- changed ed25519 part names and format
- * [1,6] -- type arguments for hash() and fingerprint()
- */
-PrivateKey.prototype._sshpkApiVersion = [1, 6];
-
-PrivateKey._oldVersionDetect = function (obj) {
-	assert.func(obj.toPublic);
-	assert.func(obj.createSign);
-	if (obj.derive)
-		return ([1, 3]);
-	if (obj.defaultHashAlgorithm)
-		return ([1, 2]);
-	if (obj.formats['auto'])
-		return ([1, 1]);
-	return ([1, 0]);
-};

package/example/node_modules/sshpk/lib/signature.js

@@ -1,314 +0,0 @@
-// Copyright 2015 Joyent, Inc.
-
-module.exports = Signature;
-
-var assert = require('assert-plus');
-var Buffer = require('safer-buffer').Buffer;
-var algs = require('./algs');
-var crypto = require('crypto');
-var errs = require('./errors');
-var utils = require('./utils');
-var asn1 = require('asn1');
-var SSHBuffer = require('./ssh-buffer');
-
-var InvalidAlgorithmError = errs.InvalidAlgorithmError;
-var SignatureParseError = errs.SignatureParseError;
-
-function Signature(opts) {
-	assert.object(opts, 'options');
-	assert.arrayOfObject(opts.parts, 'options.parts');
-	assert.string(opts.type, 'options.type');
-
-	var partLookup = {};
-	for (var i = 0; i < opts.parts.length; ++i) {
-		var part = opts.parts[i];
-		partLookup[part.name] = part;
-	}
-
-	this.type = opts.type;
-	this.hashAlgorithm = opts.hashAlgo;
-	this.curve = opts.curve;
-	this.parts = opts.parts;
-	this.part = partLookup;
-}
-
-Signature.prototype.toBuffer = function (format) {
-	if (format === undefined)
-		format = 'asn1';
-	assert.string(format, 'format');
-
-	var buf;
-	var stype = 'ssh-' + this.type;
-
-	switch (this.type) {
-	case 'rsa':
-		switch (this.hashAlgorithm) {
-		case 'sha256':
-			stype = 'rsa-sha2-256';
-			break;
-		case 'sha512':
-			stype = 'rsa-sha2-512';
-			break;
-		case 'sha1':
-		case undefined:
-			break;
-		default:
-			throw (new Error('SSH signature ' +
-			    'format does not support hash ' +
-			    'algorithm ' + this.hashAlgorithm));
-		}
-		if (format === 'ssh') {
-			buf = new SSHBuffer({});
-			buf.writeString(stype);
-			buf.writePart(this.part.sig);
-			return (buf.toBuffer());
-		} else {
-			return (this.part.sig.data);
-		}
-		break;
-
-	case 'ed25519':
-		if (format === 'ssh') {
-			buf = new SSHBuffer({});
-			buf.writeString(stype);
-			buf.writePart(this.part.sig);
-			return (buf.toBuffer());
-		} else {
-			return (this.part.sig.data);
-		}
-		break;
-
-	case 'dsa':
-	case 'ecdsa':
-		var r, s;
-		if (format === 'asn1') {
-			var der = new asn1.BerWriter();
-			der.startSequence();
-			r = utils.mpNormalize(this.part.r.data);
-			s = utils.mpNormalize(this.part.s.data);
-			der.writeBuffer(r, asn1.Ber.Integer);
-			der.writeBuffer(s, asn1.Ber.Integer);
-			der.endSequence();
-			return (der.buffer);
-		} else if (format === 'ssh' && this.type === 'dsa') {
-			buf = new SSHBuffer({});
-			buf.writeString('ssh-dss');
-			r = this.part.r.data;
-			if (r.length > 20 && r[0] === 0x00)
-				r = r.slice(1);
-			s = this.part.s.data;
-			if (s.length > 20 && s[0] === 0x00)
-				s = s.slice(1);
-			if ((this.hashAlgorithm &&
-			    this.hashAlgorithm !== 'sha1') ||
-			    r.length + s.length !== 40) {
-				throw (new Error('OpenSSH only supports ' +
-				    'DSA signatures with SHA1 hash'));
-			}
-			buf.writeBuffer(Buffer.concat([r, s]));
-			return (buf.toBuffer());
-		} else if (format === 'ssh' && this.type === 'ecdsa') {
-			var inner = new SSHBuffer({});
-			r = this.part.r.data;
-			inner.writeBuffer(r);
-			inner.writePart(this.part.s);
-
-			buf = new SSHBuffer({});
-			/* XXX: find a more proper way to do this? */
-			var curve;
-			if (r[0] === 0x00)
-				r = r.slice(1);
-			var sz = r.length * 8;
-			if (sz === 256)
-				curve = 'nistp256';
-			else if (sz === 384)
-				curve = 'nistp384';
-			else if (sz === 528)
-				curve = 'nistp521';
-			buf.writeString('ecdsa-sha2-' + curve);
-			buf.writeBuffer(inner.toBuffer());
-			return (buf.toBuffer());
-		}
-		throw (new Error('Invalid signature format'));
-	default:
-		throw (new Error('Invalid signature data'));
-	}
-};
-
-Signature.prototype.toString = function (format) {
-	assert.optionalString(format, 'format');
-	return (this.toBuffer(format).toString('base64'));
-};
-
-Signature.parse = function (data, type, format) {
-	if (typeof (data) === 'string')
-		data = Buffer.from(data, 'base64');
-	assert.buffer(data, 'data');
-	assert.string(format, 'format');
-	assert.string(type, 'type');
-
-	var opts = {};
-	opts.type = type.toLowerCase();
-	opts.parts = [];
-
-	try {
-		assert.ok(data.length > 0, 'signature must not be empty');
-		switch (opts.type) {
-		case 'rsa':
-			return (parseOneNum(data, type, format, opts));
-		case 'ed25519':
-			return (parseOneNum(data, type, format, opts));
-
-		case 'dsa':
-		case 'ecdsa':
-			if (format === 'asn1')
-				return (parseDSAasn1(data, type, format, opts));
-			else if (opts.type === 'dsa')
-				return (parseDSA(data, type, format, opts));
-			else
-				return (parseECDSA(data, type, format, opts));
-
-		default:
-			throw (new InvalidAlgorithmError(type));
-		}
-
-	} catch (e) {
-		if (e instanceof InvalidAlgorithmError)
-			throw (e);
-		throw (new SignatureParseError(type, format, e));
-	}
-};
-
-function parseOneNum(data, type, format, opts) {
-	if (format === 'ssh') {
-		try {
-			var buf = new SSHBuffer({buffer: data});
-			var head = buf.readString();
-		} catch (e) {
-			/* fall through */
-		}
-		if (buf !== undefined) {
-			var msg = 'SSH signature does not match expected ' +
-			    'type (expected ' + type + ', got ' + head + ')';
-			switch (head) {
-			case 'ssh-rsa':
-				assert.strictEqual(type, 'rsa', msg);
-				opts.hashAlgo = 'sha1';
-				break;
-			case 'rsa-sha2-256':
-				assert.strictEqual(type, 'rsa', msg);
-				opts.hashAlgo = 'sha256';
-				break;
-			case 'rsa-sha2-512':
-				assert.strictEqual(type, 'rsa', msg);
-				opts.hashAlgo = 'sha512';
-				break;
-			case 'ssh-ed25519':
-				assert.strictEqual(type, 'ed25519', msg);
-				opts.hashAlgo = 'sha512';
-				break;
-			default:
-				throw (new Error('Unknown SSH signature ' +
-				    'type: ' + head));
-			}
-			var sig = buf.readPart();
-			assert.ok(buf.atEnd(), 'extra trailing bytes');
-			sig.name = 'sig';
-			opts.parts.push(sig);
-			return (new Signature(opts));
-		}
-	}
-	opts.parts.push({name: 'sig', data: data});
-	return (new Signature(opts));
-}
-
-function parseDSAasn1(data, type, format, opts) {
-	var der = new asn1.BerReader(data);
-	der.readSequence();
-	var r = der.readString(asn1.Ber.Integer, true);
-	var s = der.readString(asn1.Ber.Integer, true);
-
-	opts.parts.push({name: 'r', data: utils.mpNormalize(r)});
-	opts.parts.push({name: 's', data: utils.mpNormalize(s)});
-
-	return (new Signature(opts));
-}
-
-function parseDSA(data, type, format, opts) {
-	if (data.length != 40) {
-		var buf = new SSHBuffer({buffer: data});
-		var d = buf.readBuffer();
-		if (d.toString('ascii') === 'ssh-dss')
-			d = buf.readBuffer();
-		assert.ok(buf.atEnd(), 'extra trailing bytes');
-		assert.strictEqual(d.length, 40, 'invalid inner length');
-		data = d;
-	}
-	opts.parts.push({name: 'r', data: data.slice(0, 20)});
-	opts.parts.push({name: 's', data: data.slice(20, 40)});
-	return (new Signature(opts));
-}
-
-function parseECDSA(data, type, format, opts) {
-	var buf = new SSHBuffer({buffer: data});
-
-	var r, s;
-	var inner = buf.readBuffer();
-	var stype = inner.toString('ascii');
-	if (stype.slice(0, 6) === 'ecdsa-') {
-		var parts = stype.split('-');
-		assert.strictEqual(parts[0], 'ecdsa');
-		assert.strictEqual(parts[1], 'sha2');
-		opts.curve = parts[2];
-		switch (opts.curve) {
-		case 'nistp256':
-			opts.hashAlgo = 'sha256';
-			break;
-		case 'nistp384':
-			opts.hashAlgo = 'sha384';
-			break;
-		case 'nistp521':
-			opts.hashAlgo = 'sha512';
-			break;
-		default:
-			throw (new Error('Unsupported ECDSA curve: ' +
-			    opts.curve));
-		}
-		inner = buf.readBuffer();
-		assert.ok(buf.atEnd(), 'extra trailing bytes on outer');
-		buf = new SSHBuffer({buffer: inner});
-		r = buf.readPart();
-	} else {
-		r = {data: inner};
-	}
-
-	s = buf.readPart();
-	assert.ok(buf.atEnd(), 'extra trailing bytes');
-
-	r.name = 'r';
-	s.name = 's';
-
-	opts.parts.push(r);
-	opts.parts.push(s);
-	return (new Signature(opts));
-}
-
-Signature.isSignature = function (obj, ver) {
-	return (utils.isCompatible(obj, Signature, ver));
-};
-
-/*
- * API versions for Signature:
- * [1,0] -- initial ver
- * [2,0] -- support for rsa in full ssh format, compat with sshpk-agent
- *          hashAlgorithm property
- * [2,1] -- first tagged version
- */
-Signature.prototype._sshpkApiVersion = [2, 1];
-
-Signature._oldVersionDetect = function (obj) {
-	assert.func(obj.toBuffer);
-	if (obj.hasOwnProperty('hashAlgorithm'))
-		return ([2, 0]);
-	return ([1, 0]);
-};

package/example/node_modules/sshpk/lib/ssh-buffer.js

@@ -1,149 +0,0 @@
-// Copyright 2015 Joyent, Inc.
-
-module.exports = SSHBuffer;
-
-var assert = require('assert-plus');
-var Buffer = require('safer-buffer').Buffer;
-
-function SSHBuffer(opts) {
-	assert.object(opts, 'options');
-	if (opts.buffer !== undefined)
-		assert.buffer(opts.buffer, 'options.buffer');
-
-	this._size = opts.buffer ? opts.buffer.length : 1024;
-	this._buffer = opts.buffer || Buffer.alloc(this._size);
-	this._offset = 0;
-}
-
-SSHBuffer.prototype.toBuffer = function () {
-	return (this._buffer.slice(0, this._offset));
-};
-
-SSHBuffer.prototype.atEnd = function () {
-	return (this._offset >= this._buffer.length);
-};
-
-SSHBuffer.prototype.remainder = function () {
-	return (this._buffer.slice(this._offset));
-};
-
-SSHBuffer.prototype.skip = function (n) {
-	this._offset += n;
-};
-
-SSHBuffer.prototype.expand = function () {
-	this._size *= 2;
-	var buf = Buffer.alloc(this._size);
-	this._buffer.copy(buf, 0);
-	this._buffer = buf;
-};
-
-SSHBuffer.prototype.readPart = function () {
-	return ({data: this.readBuffer()});
-};
-
-SSHBuffer.prototype.readBuffer = function () {
-	var len = this._buffer.readUInt32BE(this._offset);
-	this._offset += 4;
-	assert.ok(this._offset + len <= this._buffer.length,
-	    'length out of bounds at +0x' + this._offset.toString(16) +
-	    ' (data truncated?)');
-	var buf = this._buffer.slice(this._offset, this._offset + len);
-	this._offset += len;
-	return (buf);
-};
-
-SSHBuffer.prototype.readString = function () {
-	return (this.readBuffer().toString());
-};
-
-SSHBuffer.prototype.readCString = function () {
-	var offset = this._offset;
-	while (offset < this._buffer.length &&
-	    this._buffer[offset] !== 0x00)
-		offset++;
-	assert.ok(offset < this._buffer.length, 'c string does not terminate');
-	var str = this._buffer.slice(this._offset, offset).toString();
-	this._offset = offset + 1;
-	return (str);
-};
-
-SSHBuffer.prototype.readInt = function () {
-	var v = this._buffer.readUInt32BE(this._offset);
-	this._offset += 4;
-	return (v);
-};
-
-SSHBuffer.prototype.readInt64 = function () {
-	assert.ok(this._offset + 8 < this._buffer.length,
-	    'buffer not long enough to read Int64');
-	var v = this._buffer.slice(this._offset, this._offset + 8);
-	this._offset += 8;
-	return (v);
-};
-
-SSHBuffer.prototype.readChar = function () {
-	var v = this._buffer[this._offset++];
-	return (v);
-};
-
-SSHBuffer.prototype.writeBuffer = function (buf) {
-	while (this._offset + 4 + buf.length > this._size)
-		this.expand();
-	this._buffer.writeUInt32BE(buf.length, this._offset);
-	this._offset += 4;
-	buf.copy(this._buffer, this._offset);
-	this._offset += buf.length;
-};
-
-SSHBuffer.prototype.writeString = function (str) {
-	this.writeBuffer(Buffer.from(str, 'utf8'));
-};
-
-SSHBuffer.prototype.writeCString = function (str) {
-	while (this._offset + 1 + str.length > this._size)
-		this.expand();
-	this._buffer.write(str, this._offset);
-	this._offset += str.length;
-	this._buffer[this._offset++] = 0;
-};
-
-SSHBuffer.prototype.writeInt = function (v) {
-	while (this._offset + 4 > this._size)
-		this.expand();
-	this._buffer.writeUInt32BE(v, this._offset);
-	this._offset += 4;
-};
-
-SSHBuffer.prototype.writeInt64 = function (v) {
-	assert.buffer(v, 'value');
-	if (v.length > 8) {
-		var lead = v.slice(0, v.length - 8);
-		for (var i = 0; i < lead.length; ++i) {
-			assert.strictEqual(lead[i], 0,
-			    'must fit in 64 bits of precision');
-		}
-		v = v.slice(v.length - 8, v.length);
-	}
-	while (this._offset + 8 > this._size)
-		this.expand();
-	v.copy(this._buffer, this._offset);
-	this._offset += 8;
-};
-
-SSHBuffer.prototype.writeChar = function (v) {
-	while (this._offset + 1 > this._size)
-		this.expand();
-	this._buffer[this._offset++] = v;
-};
-
-SSHBuffer.prototype.writePart = function (p) {
-	this.writeBuffer(p.data);
-};
-
-SSHBuffer.prototype.write = function (buf) {
-	while (this._offset + buf.length > this._size)
-		this.expand();
-	buf.copy(this._buffer, this._offset);
-	this._offset += buf.length;
-};