diff --git a/.aegir.js b/.aegir.js deleted file mode 100644 index 3faa51b2..00000000 --- a/.aegir.js +++ /dev/null @@ -1,3 +0,0 @@ -module.exports = { - bundlesize: { maxSize: '124kB' } -} diff --git a/.travis.yml b/.travis.yml index 00e0e5fc..404f8691 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,15 +1,19 @@ language: node_js - cache: npm +branches: + only: + - master + - /^release\/.*$/ + stages: - check - test - cov node_js: - - '10' - - '12' + - 'lts/*' + - 'node' os: - linux @@ -23,7 +27,7 @@ jobs: include: - stage: check script: - - npx aegir build --bundlesize + - npx aegir build --no-types - npx aegir dep-check - npm run lint diff --git a/package.json b/package.json index 554459f6..48636fe3 100644 --- a/package.json +++ b/package.json @@ -18,8 +18,8 @@ ], "scripts": { "lint": "aegir lint", - "build": "aegir build", - "build-proto": "pbjs --wrap commonjs --target static-module src/keys/keys.proto > src/keys/keys.proto.js", + "build": "npm run build:proto && aegir build --no-types", + "build:proto": "pbjs -t static-module -w commonjs --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/keys/keys.js ./src/keys/keys.proto", "test": "aegir test", "test:node": "aegir test -t node", "test:browser": "aegir test -t browser -t webworker", @@ -39,19 +39,19 @@ ], "license": "MIT", "dependencies": { - "err-code": "^2.0.0", + "err-code": "^3.0.1", "is-typedarray": "^1.0.0", - "iso-random-stream": "^1.1.0", + "iso-random-stream": "^2.0.0", "keypair": "^1.0.1", - "multibase": "^3.0.0", - "multicodec": "^2.0.0", + "multibase": "^4.0.3", + "multicodec": "^3.0.1", "multihashes": "^4.0.2", - "multihashing-async": "^2.0.1", + "multihashing-async": "^2.1.2", "node-forge": "^0.10.0", "pem-jwk": "^2.0.0", - "protons": "^2.0.0", + "protobufjs": "^6.10.2", "secp256k1": "^4.0.0", - "uint8arrays": "^1.1.0", + "uint8arrays": "^2.1.4", "ursa-optional": "^0.10.1" }, "devDependencies": { @@ -59,16 +59,21 @@ "@types/chai-string": "^1.4.2", "@types/dirty-chai": "^2.0.2", "@types/mocha": "^8.0.1", - "aegir": "^25.0.0", + "aegir": "^33.0.0", "benchmark": "^2.1.4", "chai": "^4.2.0", "chai-string": "^1.5.0", "dirty-chai": "^2.0.1", - "sinon": "^9.0.0" + "sinon": "^10.0.0", + "util": "^0.12.3" + }, + "aegir": { + "build": { + "bundlesizeMax": "118kB" + } }, "engines": { - "node": ">=10.0.0", - "npm": ">=6.0.0" + "node": ">=12.0.0" }, "repository": { "type": "git", diff --git a/src/ciphers/aes-gcm.browser.js b/src/ciphers/aes-gcm.browser.js index 3caf67c6..b3009768 100644 --- a/src/ciphers/aes-gcm.browser.js +++ b/src/ciphers/aes-gcm.browser.js @@ -11,11 +11,11 @@ const webcrypto = require('../webcrypto') * * @param {object} [options] * @param {string} [options.algorithm=AES-GCM] - * @param {Number} [options.nonceLength=12] - * @param {Number} [options.keyLength=16] + * @param {number} [options.nonceLength=12] + * @param {number} [options.keyLength=16] * @param {string} [options.digest=sha256] - * @param {Number} [options.saltLength=16] - * @param {Number} [options.iterations=32767] + * @param {number} [options.saltLength=16] + * @param {number} [options.iterations=32767] * @returns {*} */ function create ({ @@ -33,8 +33,8 @@ function create ({ * Uses the provided password to derive a pbkdf2 key. The key * will then be used to encrypt the data. * - * @param {Uint8Array} data The data to decrypt - * @param {string} password A plain password + * @param {Uint8Array} data - The data to decrypt + * @param {string} password - A plain password * @returns {Promise} */ async function encrypt (data, password) { // eslint-disable-line require-await @@ -58,8 +58,8 @@ function create ({ * this decryption cipher must be the same as those used to create * the encryption cipher. * - * @param {Uint8Array} data The data to decrypt - * @param {string} password A plain password + * @param {Uint8Array} data - The data to decrypt + * @param {string} password - A plain password * @returns {Promise} */ async function decrypt (data, password) { diff --git a/src/ciphers/aes-gcm.js b/src/ciphers/aes-gcm.js index c4719541..3ee2caa8 100644 --- a/src/ciphers/aes-gcm.js +++ b/src/ciphers/aes-gcm.js @@ -9,12 +9,12 @@ const uint8ArrayFromString = require('uint8arrays/from-string') /** * * @param {object} [options] - * @param {Number} [options.algorithmTagLength=16] - * @param {Number} [options.nonceLength=12] - * @param {Number} [options.keyLength=16] + * @param {number} [options.algorithmTagLength=16] + * @param {number} [options.nonceLength=12] + * @param {number} [options.keyLength=16] * @param {string} [options.digest=sha256] - * @param {Number} [options.saltLength=16] - * @param {Number} [options.iterations=32767] + * @param {number} [options.saltLength=16] + * @param {number} [options.iterations=32767] * @returns {*} */ function create ({ @@ -49,8 +49,8 @@ function create ({ * Uses the provided password to derive a pbkdf2 key. The key * will then be used to encrypt the data. * - * @param {Uint8Array} data The data to decrypt - * @param {string|Uint8Array} password A plain password + * @param {Uint8Array} data - The data to decrypt + * @param {string|Uint8Array} password - A plain password * @returns {Promise} */ async function encrypt (data, password) { // eslint-disable-line require-await @@ -76,7 +76,7 @@ function create ({ * the encryption cipher. * * @private - * @param {Uint8Array} ciphertextAndNonce The data to decrypt + * @param {Uint8Array} ciphertextAndNonce - The data to decrypt * @param {Uint8Array} key * @returns {Promise} */ @@ -100,8 +100,8 @@ function create ({ * this decryption cipher must be the same as those used to create * the encryption cipher. * - * @param {Uint8Array} data The data to decrypt - * @param {string|Uint8Array} password A plain password + * @param {Uint8Array} data - The data to decrypt + * @param {string|Uint8Array} password - A plain password */ async function decrypt (data, password) { // eslint-disable-line require-await // Create Uint8Arrays of salt and ciphertextAndNonce. diff --git a/src/keys/ed25519-class.js b/src/keys/ed25519-class.js index b6b549ea..4d324deb 100644 --- a/src/keys/ed25519-class.js +++ b/src/keys/ed25519-class.js @@ -1,12 +1,11 @@ 'use strict' const sha = require('multihashing-async/src/sha') -const protobuf = require('protons') const errcode = require('err-code') const uint8ArrayEquals = require('uint8arrays/equals') const mh = require('multihashes') const crypto = require('./ed25519') -const pbm = protobuf(require('./keys.proto')) +const pbm = require('./keys') const exporter = require('./exporter') class Ed25519PublicKey { @@ -26,7 +25,7 @@ class Ed25519PublicKey { return pbm.PublicKey.encode({ Type: pbm.KeyType.Ed25519, Data: this.marshal() - }) + }).finish() } equals (key) { @@ -62,7 +61,7 @@ class Ed25519PrivateKey { return pbm.PrivateKey.encode({ Type: pbm.KeyType.Ed25519, Data: this.marshal() - }) + }).finish() } equals (key) { @@ -80,7 +79,7 @@ class Ed25519PrivateKey { * The public key is a protobuf encoding containing a type and the DER encoding * of the PKCS SubjectPublicKeyInfo. * - * @returns {Promise} + * @returns {Promise} */ async id () { const encoding = mh.encode(this.public.bytes, 'identity') diff --git a/src/keys/exporter.js b/src/keys/exporter.js index 718bd583..0dabd4e0 100644 --- a/src/keys/exporter.js +++ b/src/keys/exporter.js @@ -9,7 +9,7 @@ module.exports = { * The PrivateKey is encrypted via a password derived PBKDF2 key * leveraging the aes-gcm cipher algorithm. * - * @param {Uint8Array} privateKey The PrivateKey protobuf + * @param {Uint8Array} privateKey - The PrivateKey protobuf * @param {string} password * @returns {Promise} A base64 encoded string */ diff --git a/src/keys/importer.js b/src/keys/importer.js index 6e5d99d7..0aeb0ca2 100644 --- a/src/keys/importer.js +++ b/src/keys/importer.js @@ -9,7 +9,7 @@ module.exports = { * with the given password. The privateKey must have been exported * using the same password and underlying cipher (aes-gcm) * - * @param {string} privateKey A base64 encoded encrypted key + * @param {string} privateKey - A base64 encoded encrypted key * @param {string} password * @returns {Promise} The private key protobuf */ diff --git a/src/keys/index.js b/src/keys/index.js index 36684d99..320a781f 100644 --- a/src/keys/index.js +++ b/src/keys/index.js @@ -1,7 +1,6 @@ 'use strict' -const protobuf = require('protons') -const keysPBM = protobuf(require('./keys.proto')) +const keysPBM = require('./keys') require('node-forge/lib/asn1') require('node-forge/lib/pbe') const forge = require('node-forge/lib/forge') @@ -10,17 +9,12 @@ const uint8ArrayFromString = require('uint8arrays/from-string') const importer = require('./importer') -exports = module.exports - const supportedKeys = { rsa: require('./rsa-class'), ed25519: require('./ed25519-class'), secp256k1: require('./secp256k1-class')(keysPBM, require('../random-bytes')) } -exports.supportedKeys = supportedKeys -exports.keysPBM = keysPBM - const ErrMissingSecp256K1 = { message: 'secp256k1 support requires libp2p-crypto-secp256k1 package', code: 'ERR_MISSING_PACKAGE' @@ -35,17 +29,14 @@ function typeToKey (type) { return key } -exports.keyStretcher = require('./key-stretcher') -exports.generateEphemeralKeyPair = require('./ephemeral-keys') - // Generates a keypair of the given type and bitsize -exports.generateKeyPair = async (type, bits) => { // eslint-disable-line require-await +const generateKeyPair = async (type, bits) => { // eslint-disable-line require-await return typeToKey(type).generateKeyPair(bits) } // Generates a keypair of the given type and bitsize // seed is a 32 byte uint8array -exports.generateKeyPairFromSeed = async (type, seed, bits) => { // eslint-disable-line require-await +const generateKeyPairFromSeed = async (type, seed, bits) => { // eslint-disable-line require-await const key = typeToKey(type) if (type.toLowerCase() !== 'ed25519') { throw errcode(new Error('Seed key derivation is unimplemented for RSA or secp256k1'), 'ERR_UNSUPPORTED_KEY_DERIVATION_TYPE') @@ -55,7 +46,7 @@ exports.generateKeyPairFromSeed = async (type, seed, bits) => { // eslint-disabl // Converts a protobuf serialized public key into its // representative object -exports.unmarshalPublicKey = (buf) => { +const unmarshalPublicKey = (buf) => { const decoded = keysPBM.PublicKey.decode(buf) const data = decoded.Data @@ -76,7 +67,7 @@ exports.unmarshalPublicKey = (buf) => { } // Converts a public key object into a protobuf serialized public key -exports.marshalPublicKey = (key, type) => { +const marshalPublicKey = (key, type) => { type = (type || 'rsa').toLowerCase() typeToKey(type) // check type return key.bytes @@ -84,7 +75,7 @@ exports.marshalPublicKey = (key, type) => { // Converts a protobuf serialized private key into its // representative object -exports.unmarshalPrivateKey = async (buf) => { // eslint-disable-line require-await +const unmarshalPrivateKey = async (buf) => { // eslint-disable-line require-await const decoded = keysPBM.PrivateKey.decode(buf) const data = decoded.Data @@ -105,7 +96,7 @@ exports.unmarshalPrivateKey = async (buf) => { // eslint-disable-line require-aw } // Converts a private key object into a protobuf serialized private key -exports.marshalPrivateKey = (key, type) => { +const marshalPrivateKey = (key, type) => { type = (type || 'rsa').toLowerCase() typeToKey(type) // check type return key.bytes @@ -116,10 +107,10 @@ exports.marshalPrivateKey = (key, type) => { * @param {string} encryptedKey * @param {string} password */ -exports.import = async (encryptedKey, password) => { // eslint-disable-line require-await +const importKey = async (encryptedKey, password) => { // eslint-disable-line require-await try { const key = await importer.import(encryptedKey, password) - return exports.unmarshalPrivateKey(key) + return unmarshalPrivateKey(key) } catch (_) { // Ignore and try the old pem decrypt } @@ -133,3 +124,17 @@ exports.import = async (encryptedKey, password) => { // eslint-disable-line requ der = uint8ArrayFromString(der.getBytes(), 'ascii') return supportedKeys.rsa.unmarshalRsaPrivateKey(der) } + +module.exports = { + supportedKeys, + keysPBM, + keyStretcher: require('./key-stretcher'), + generateEphemeralKeyPair: require('./ephemeral-keys'), + generateKeyPair, + generateKeyPairFromSeed, + unmarshalPublicKey, + marshalPublicKey, + unmarshalPrivateKey, + marshalPrivateKey, + import: importKey +} diff --git a/src/keys/keys.js b/src/keys/keys.js new file mode 100644 index 00000000..33c368cc --- /dev/null +++ b/src/keys/keys.js @@ -0,0 +1,378 @@ +/*eslint-disable*/ +"use strict"; + +var $protobuf = require("protobufjs/minimal"); + +// Common aliases +var $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util; + +// Exported root namespace +var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {}); + +/** + * KeyType enum. + * @exports KeyType + * @enum {number} + * @property {number} RSA=0 RSA value + * @property {number} Ed25519=1 Ed25519 value + * @property {number} Secp256k1=2 Secp256k1 value + */ +$root.KeyType = (function() { + var valuesById = {}, values = Object.create(valuesById); + values[valuesById[0] = "RSA"] = 0; + values[valuesById[1] = "Ed25519"] = 1; + values[valuesById[2] = "Secp256k1"] = 2; + return values; +})(); + +$root.PublicKey = (function() { + + /** + * Properties of a PublicKey. + * @exports IPublicKey + * @interface IPublicKey + * @property {KeyType} Type PublicKey Type + * @property {Uint8Array} Data PublicKey Data + */ + + /** + * Constructs a new PublicKey. + * @exports PublicKey + * @classdesc Represents a PublicKey. + * @implements IPublicKey + * @constructor + * @param {IPublicKey=} [p] Properties to set + */ + function PublicKey(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) + this[ks[i]] = p[ks[i]]; + } + + /** + * PublicKey Type. + * @member {KeyType} Type + * @memberof PublicKey + * @instance + */ + PublicKey.prototype.Type = 0; + + /** + * PublicKey Data. + * @member {Uint8Array} Data + * @memberof PublicKey + * @instance + */ + PublicKey.prototype.Data = $util.newBuffer([]); + + /** + * Encodes the specified PublicKey message. Does not implicitly {@link PublicKey.verify|verify} messages. + * @function encode + * @memberof PublicKey + * @static + * @param {IPublicKey} m PublicKey message or plain object to encode + * @param {$protobuf.Writer} [w] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + PublicKey.encode = function encode(m, w) { + if (!w) + w = $Writer.create(); + w.uint32(8).int32(m.Type); + w.uint32(18).bytes(m.Data); + return w; + }; + + /** + * Decodes a PublicKey message from the specified reader or buffer. + * @function decode + * @memberof PublicKey + * @static + * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from + * @param {number} [l] Message length if known beforehand + * @returns {PublicKey} PublicKey + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + PublicKey.decode = function decode(r, l) { + if (!(r instanceof $Reader)) + r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, m = new $root.PublicKey(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.Type = r.int32(); + break; + case 2: + m.Data = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + if (!m.hasOwnProperty("Type")) + throw $util.ProtocolError("missing required 'Type'", { instance: m }); + if (!m.hasOwnProperty("Data")) + throw $util.ProtocolError("missing required 'Data'", { instance: m }); + return m; + }; + + /** + * Creates a PublicKey message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof PublicKey + * @static + * @param {Object.} d Plain object + * @returns {PublicKey} PublicKey + */ + PublicKey.fromObject = function fromObject(d) { + if (d instanceof $root.PublicKey) + return d; + var m = new $root.PublicKey(); + switch (d.Type) { + case "RSA": + case 0: + m.Type = 0; + break; + case "Ed25519": + case 1: + m.Type = 1; + break; + case "Secp256k1": + case 2: + m.Type = 2; + break; + } + if (d.Data != null) { + if (typeof d.Data === "string") + $util.base64.decode(d.Data, m.Data = $util.newBuffer($util.base64.length(d.Data)), 0); + else if (d.Data.length) + m.Data = d.Data; + } + return m; + }; + + /** + * Creates a plain object from a PublicKey message. Also converts values to other types if specified. + * @function toObject + * @memberof PublicKey + * @static + * @param {PublicKey} m PublicKey + * @param {$protobuf.IConversionOptions} [o] Conversion options + * @returns {Object.} Plain object + */ + PublicKey.toObject = function toObject(m, o) { + if (!o) + o = {}; + var d = {}; + if (o.defaults) { + d.Type = o.enums === String ? "RSA" : 0; + if (o.bytes === String) + d.Data = ""; + else { + d.Data = []; + if (o.bytes !== Array) + d.Data = $util.newBuffer(d.Data); + } + } + if (m.Type != null && m.hasOwnProperty("Type")) { + d.Type = o.enums === String ? $root.KeyType[m.Type] : m.Type; + } + if (m.Data != null && m.hasOwnProperty("Data")) { + d.Data = o.bytes === String ? $util.base64.encode(m.Data, 0, m.Data.length) : o.bytes === Array ? Array.prototype.slice.call(m.Data) : m.Data; + } + return d; + }; + + /** + * Converts this PublicKey to JSON. + * @function toJSON + * @memberof PublicKey + * @instance + * @returns {Object.} JSON object + */ + PublicKey.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return PublicKey; +})(); + +$root.PrivateKey = (function() { + + /** + * Properties of a PrivateKey. + * @exports IPrivateKey + * @interface IPrivateKey + * @property {KeyType} Type PrivateKey Type + * @property {Uint8Array} Data PrivateKey Data + */ + + /** + * Constructs a new PrivateKey. + * @exports PrivateKey + * @classdesc Represents a PrivateKey. + * @implements IPrivateKey + * @constructor + * @param {IPrivateKey=} [p] Properties to set + */ + function PrivateKey(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) + this[ks[i]] = p[ks[i]]; + } + + /** + * PrivateKey Type. + * @member {KeyType} Type + * @memberof PrivateKey + * @instance + */ + PrivateKey.prototype.Type = 0; + + /** + * PrivateKey Data. + * @member {Uint8Array} Data + * @memberof PrivateKey + * @instance + */ + PrivateKey.prototype.Data = $util.newBuffer([]); + + /** + * Encodes the specified PrivateKey message. Does not implicitly {@link PrivateKey.verify|verify} messages. + * @function encode + * @memberof PrivateKey + * @static + * @param {IPrivateKey} m PrivateKey message or plain object to encode + * @param {$protobuf.Writer} [w] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + PrivateKey.encode = function encode(m, w) { + if (!w) + w = $Writer.create(); + w.uint32(8).int32(m.Type); + w.uint32(18).bytes(m.Data); + return w; + }; + + /** + * Decodes a PrivateKey message from the specified reader or buffer. + * @function decode + * @memberof PrivateKey + * @static + * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from + * @param {number} [l] Message length if known beforehand + * @returns {PrivateKey} PrivateKey + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + PrivateKey.decode = function decode(r, l) { + if (!(r instanceof $Reader)) + r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, m = new $root.PrivateKey(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.Type = r.int32(); + break; + case 2: + m.Data = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + if (!m.hasOwnProperty("Type")) + throw $util.ProtocolError("missing required 'Type'", { instance: m }); + if (!m.hasOwnProperty("Data")) + throw $util.ProtocolError("missing required 'Data'", { instance: m }); + return m; + }; + + /** + * Creates a PrivateKey message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof PrivateKey + * @static + * @param {Object.} d Plain object + * @returns {PrivateKey} PrivateKey + */ + PrivateKey.fromObject = function fromObject(d) { + if (d instanceof $root.PrivateKey) + return d; + var m = new $root.PrivateKey(); + switch (d.Type) { + case "RSA": + case 0: + m.Type = 0; + break; + case "Ed25519": + case 1: + m.Type = 1; + break; + case "Secp256k1": + case 2: + m.Type = 2; + break; + } + if (d.Data != null) { + if (typeof d.Data === "string") + $util.base64.decode(d.Data, m.Data = $util.newBuffer($util.base64.length(d.Data)), 0); + else if (d.Data.length) + m.Data = d.Data; + } + return m; + }; + + /** + * Creates a plain object from a PrivateKey message. Also converts values to other types if specified. + * @function toObject + * @memberof PrivateKey + * @static + * @param {PrivateKey} m PrivateKey + * @param {$protobuf.IConversionOptions} [o] Conversion options + * @returns {Object.} Plain object + */ + PrivateKey.toObject = function toObject(m, o) { + if (!o) + o = {}; + var d = {}; + if (o.defaults) { + d.Type = o.enums === String ? "RSA" : 0; + if (o.bytes === String) + d.Data = ""; + else { + d.Data = []; + if (o.bytes !== Array) + d.Data = $util.newBuffer(d.Data); + } + } + if (m.Type != null && m.hasOwnProperty("Type")) { + d.Type = o.enums === String ? $root.KeyType[m.Type] : m.Type; + } + if (m.Data != null && m.hasOwnProperty("Data")) { + d.Data = o.bytes === String ? $util.base64.encode(m.Data, 0, m.Data.length) : o.bytes === Array ? Array.prototype.slice.call(m.Data) : m.Data; + } + return d; + }; + + /** + * Converts this PrivateKey to JSON. + * @function toJSON + * @memberof PrivateKey + * @instance + * @returns {Object.} JSON object + */ + PrivateKey.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return PrivateKey; +})(); + +module.exports = $root; diff --git a/src/keys/keys.proto.js b/src/keys/keys.proto similarity index 80% rename from src/keys/keys.proto.js rename to src/keys/keys.proto index 4e0ab088..98e1d997 100644 --- a/src/keys/keys.proto.js +++ b/src/keys/keys.proto @@ -1,6 +1,6 @@ -'use strict' +syntax = "proto3"; -module.exports = `enum KeyType { +enum KeyType { RSA = 0; Ed25519 = 1; Secp256k1 = 2; @@ -12,4 +12,4 @@ message PublicKey { message PrivateKey { required KeyType Type = 1; required bytes Data = 2; -}` +} diff --git a/src/keys/rsa-class.js b/src/keys/rsa-class.js index 0aab9988..38e14bce 100644 --- a/src/keys/rsa-class.js +++ b/src/keys/rsa-class.js @@ -1,7 +1,6 @@ 'use strict' const sha = require('multihashing-async/src/sha') -const protobuf = require('protons') const errcode = require('err-code') const uint8ArrayEquals = require('uint8arrays/equals') const uint8ArrayToString = require('uint8arrays/to-string') @@ -11,7 +10,7 @@ require('node-forge/lib/ed25519') const forge = require('node-forge/lib/forge') const crypto = require('./rsa') -const pbm = protobuf(require('./keys.proto')) +const pbm = require('./keys') const exporter = require('./exporter') class RsaPublicKey { @@ -31,7 +30,7 @@ class RsaPublicKey { return pbm.PublicKey.encode({ Type: pbm.KeyType.RSA, Data: this.marshal() - }) + }).finish() } encrypt (bytes) { @@ -83,7 +82,7 @@ class RsaPrivateKey { return pbm.PrivateKey.encode({ Type: pbm.KeyType.RSA, Data: this.marshal() - }) + }).finish() } equals (key) { @@ -101,7 +100,7 @@ class RsaPrivateKey { * The public key is a protobuf encoding containing a type and the DER encoding * of the PKCS SubjectPublicKeyInfo. * - * @returns {Promise} + * @returns {Promise} */ async id () { const hash = await this.public.hash() diff --git a/src/keys/secp256k1-class.js b/src/keys/secp256k1-class.js index 14483be6..35d735c3 100644 --- a/src/keys/secp256k1-class.js +++ b/src/keys/secp256k1-class.js @@ -28,7 +28,7 @@ module.exports = (keysProtobuf, randomBytes, crypto) => { return keysProtobuf.PublicKey.encode({ Type: keysProtobuf.KeyType.Secp256k1, Data: this.marshal() - }) + }).finish() } equals (key) { @@ -64,7 +64,7 @@ module.exports = (keysProtobuf, randomBytes, crypto) => { return keysProtobuf.PrivateKey.encode({ Type: keysProtobuf.KeyType.Secp256k1, Data: this.marshal() - }) + }).finish() } equals (key) { diff --git a/src/pbkdf2.js b/src/pbkdf2.js index 80ad0678..4d2f0a2e 100644 --- a/src/pbkdf2.js +++ b/src/pbkdf2.js @@ -23,7 +23,7 @@ const hashName = { * @param {string} password * @param {string} salt * @param {number} iterations - * @param {number} keySize (in bytes) + * @param {number} keySize - (in bytes) * @param {string} hash - The hash name ('sha1', 'sha2-512, ...) * @returns {string} - A new password */ diff --git a/test/crypto.spec.js b/test/crypto.spec.js index 4037ea7b..61f9d47b 100644 --- a/test/crypto.spec.js +++ b/test/crypto.spec.js @@ -51,7 +51,7 @@ describe('libp2p-crypto', function () { }) it('generateKeyPairFromSeed', () => { - var seed = crypto.randomBytes(32) + const seed = crypto.randomBytes(32) return expectErrCode(crypto.keys.generateKeyPairFromSeed('invalid-key-type', seed, 512), 'ERR_UNSUPPORTED_KEY_TYPE') }) diff --git a/test/keys/ed25519.spec.js b/test/keys/ed25519.spec.js index a8d35895..c0f317ef 100644 --- a/test/keys/ed25519.spec.js +++ b/test/keys/ed25519.spec.js @@ -33,7 +33,7 @@ describe('ed25519', function () { }) it('generates a valid key from seed', async () => { - var seed = crypto.randomBytes(32) + const seed = crypto.randomBytes(32) const seededkey = await crypto.keys.generateKeyPairFromSeed('Ed25519', seed, 512) expect(seededkey).to.be.an.instanceof(ed25519.Ed25519PrivateKey) const digest = await seededkey.hash()