meteor-node-stubs 1.2.8 → 1.2.9

package/node_modules/@meteorjs/crypto-browserify/index.js

@@ -0,0 +1,103 @@
+'use strict';
+
+// eslint-disable-next-line no-multi-assign
+exports.randomBytes = exports.rng = exports.pseudoRandomBytes = exports.prng = require('randombytes');
+
+// eslint-disable-next-line no-multi-assign
+exports.createHash = exports.Hash = require('create-hash');
+
+// eslint-disable-next-line no-multi-assign
+exports.createHmac = exports.Hmac = require('create-hmac');
+
+var algos = require('browserify-sign/algos');
+var algoKeys = Object.keys(algos);
+var hashes = [
+	'sha1',
+	'sha224',
+	'sha256',
+	'sha384',
+	'sha512',
+	'md5',
+	'rmd160'
+].concat(algoKeys);
+
+exports.getHashes = function () {
+	return hashes;
+};
+
+var p = require('pbkdf2');
+exports.pbkdf2 = p.pbkdf2;
+exports.pbkdf2Sync = p.pbkdf2Sync;
+
+var aes = require('browserify-cipher');
+
+exports.Cipher = aes.Cipher;
+exports.createCipher = aes.createCipher;
+exports.Cipheriv = aes.Cipheriv;
+exports.createCipheriv = aes.createCipheriv;
+exports.Decipher = aes.Decipher;
+exports.createDecipher = aes.createDecipher;
+exports.Decipheriv = aes.Decipheriv;
+exports.createDecipheriv = aes.createDecipheriv;
+exports.getCiphers = aes.getCiphers;
+exports.listCiphers = aes.listCiphers;
+
+var dh = require('diffie-hellman');
+
+exports.DiffieHellmanGroup = dh.DiffieHellmanGroup;
+exports.createDiffieHellmanGroup = dh.createDiffieHellmanGroup;
+exports.getDiffieHellman = dh.getDiffieHellman;
+exports.createDiffieHellman = dh.createDiffieHellman;
+exports.DiffieHellman = dh.DiffieHellman;
+
+var sign = require('browserify-sign');
+
+exports.createSign = sign.createSign;
+exports.Sign = sign.Sign;
+exports.createVerify = sign.createVerify;
+exports.Verify = sign.Verify;
+
+exports.createECDH = require('create-ecdh');
+
+var publicEncrypt = require('public-encrypt');
+
+exports.publicEncrypt = publicEncrypt.publicEncrypt;
+exports.privateEncrypt = publicEncrypt.privateEncrypt;
+exports.publicDecrypt = publicEncrypt.publicDecrypt;
+exports.privateDecrypt = publicEncrypt.privateDecrypt;
+
+// the least I can do is make error messages for the rest of the node.js/crypto api.
+// [
+//   'createCredentials'
+// ].forEach(function (name) {
+//   exports[name] = function () {
+//     throw new Error('sorry, ' + name + ' is not implemented yet\nwe accept pull requests\nhttps://github.com/browserify/crypto-browserify');
+//   };
+// });
+
+var rf = require('randomfill');
+
+exports.randomFill = rf.randomFill;
+exports.randomFillSync = rf.randomFillSync;
+
+exports.createCredentials = function () {
+	throw new Error('sorry, createCredentials is not implemented yet\nwe accept pull requests\nhttps://github.com/browserify/crypto-browserify');
+};
+
+exports.constants = {
+	DH_CHECK_P_NOT_SAFE_PRIME: 2,
+	DH_CHECK_P_NOT_PRIME: 1,
+	DH_UNABLE_TO_CHECK_GENERATOR: 4,
+	DH_NOT_SUITABLE_GENERATOR: 8,
+	NPN_ENABLED: 1,
+	ALPN_ENABLED: 1,
+	RSA_PKCS1_PADDING: 1,
+	RSA_SSLV23_PADDING: 2,
+	RSA_NO_PADDING: 3,
+	RSA_PKCS1_OAEP_PADDING: 4,
+	RSA_X931_PADDING: 5,
+	RSA_PKCS1_PSS_PADDING: 6,
+	POINT_CONVERSION_COMPRESSED: 2,
+	POINT_CONVERSION_UNCOMPRESSED: 4,
+	POINT_CONVERSION_HYBRID: 6
+};

package/node_modules/@meteorjs/crypto-browserify/node_modules/hash-base/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Kirill Fomichev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/node_modules/@meteorjs/crypto-browserify/node_modules/hash-base/README.md

@@ -0,0 +1,48 @@
+# hash-base
+
+[![NPM Package](https://img.shields.io/npm/v/hash-base.svg?style=flat-square)](https://www.npmjs.org/package/hash-base)
+[![Build Status](https://img.shields.io/travis/crypto-browserify/hash-base.svg?branch=master&style=flat-square)](https://travis-ci.org/crypto-browserify/hash-base)
+[![Dependency status](https://img.shields.io/david/crypto-browserify/hash-base.svg?style=flat-square)](https://david-dm.org/crypto-browserify/hash-base#info=dependencies)
+
+[![js-standard-style](https://cdn.rawgit.com/feross/standard/master/badge.svg)](https://github.com/feross/standard)
+
+Abstract base class to inherit from if you want to create streams implementing the same API as node crypto [Hash][1] (for [Cipher][2] / [Decipher][3] check [crypto-browserify/cipher-base][4]).
+
+## Example
+
+```js
+const HashBase = require('hash-base')
+const inherits = require('inherits')
+
+// our hash function is XOR sum of all bytes
+function MyHash () {
+  HashBase.call(this, 1) // in bytes
+
+  this._sum = 0x00
+}
+
+inherits(MyHash, HashBase)
+
+MyHash.prototype._update = function () {
+  for (let i = 0; i < this._block.length; ++i) this._sum ^= this._block[i]
+}
+
+MyHash.prototype._digest = function () {
+  return this._sum
+}
+
+const data = Buffer.from([ 0x00, 0x42, 0x01 ])
+const hash = new MyHash().update(data).digest()
+console.log(hash) // => 67
+```
+You also can check [source code](index.js) or [crypto-browserify/md5.js][5]
+
+## LICENSE
+
+MIT
+
+[1]: https://nodejs.org/api/crypto.html#crypto_class_hash
+[2]: https://nodejs.org/api/crypto.html#crypto_class_cipher
+[3]: https://nodejs.org/api/crypto.html#crypto_class_decipher
+[4]: https://github.com/crypto-browserify/cipher-base
+[5]: https://github.com/crypto-browserify/md5.js

package/node_modules/@meteorjs/crypto-browserify/node_modules/hash-base/index.js

@@ -0,0 +1,95 @@
+'use strict'
+var Buffer = require('safe-buffer').Buffer
+var Transform = require('stream').Transform
+var inherits = require('inherits')
+
+function throwIfNotStringOrBuffer (val, prefix) {
+  if (!Buffer.isBuffer(val) && typeof val !== 'string') {
+    throw new TypeError(prefix + ' must be a string or a buffer')
+  }
+}
+
+function HashBase (blockSize) {
+  Transform.call(this)
+
+  this._block = Buffer.allocUnsafe(blockSize)
+  this._blockSize = blockSize
+  this._blockOffset = 0
+  this._length = [0, 0, 0, 0]
+
+  this._finalized = false
+}
+
+inherits(HashBase, Transform)
+
+HashBase.prototype._transform = function (chunk, encoding, callback) {
+  var error = null
+  try {
+    this.update(chunk, encoding)
+  } catch (err) {
+    error = err
+  }
+
+  callback(error)
+}
+
+HashBase.prototype._flush = function (callback) {
+  var error = null
+  try {
+    this.push(this.digest())
+  } catch (err) {
+    error = err
+  }
+
+  callback(error)
+}
+
+HashBase.prototype.update = function (data, encoding) {
+  throwIfNotStringOrBuffer(data, 'Data')
+  if (this._finalized) throw new Error('Digest already called')
+  if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding)
+
+  // consume data
+  var block = this._block
+  var offset = 0
+  while (this._blockOffset + data.length - offset >= this._blockSize) {
+    for (var i = this._blockOffset; i < this._blockSize;) block[i++] = data[offset++]
+    this._update()
+    this._blockOffset = 0
+  }
+  while (offset < data.length) block[this._blockOffset++] = data[offset++]
+
+  // update length
+  for (var j = 0, carry = data.length * 8; carry > 0; ++j) {
+    this._length[j] += carry
+    carry = (this._length[j] / 0x0100000000) | 0
+    if (carry > 0) this._length[j] -= 0x0100000000 * carry
+  }
+
+  return this
+}
+
+HashBase.prototype._update = function () {
+  throw new Error('_update is not implemented')
+}
+
+HashBase.prototype.digest = function (encoding) {
+  if (this._finalized) throw new Error('Digest already called')
+  this._finalized = true
+
+  var digest = this._digest()
+  if (encoding !== undefined) digest = digest.toString(encoding)
+
+  // reset state
+  this._block.fill(0)
+  this._blockOffset = 0
+  for (var i = 0; i < 4; ++i) this._length[i] = 0
+
+  return digest
+}
+
+HashBase.prototype._digest = function () {
+  throw new Error('_digest is not implemented')
+}
+
+module.exports = HashBase

package/node_modules/@meteorjs/crypto-browserify/node_modules/hash-base/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "hash-base",
+  "version": "3.0.4",
+  "description": "abstract base class for hash-streams",
+  "keywords": [
+    "hash",
+    "stream"
+  ],
+  "homepage": "https://github.com/crypto-browserify/hash-base",
+  "bugs": {
+    "url": "https://github.com/crypto-browserify/hash-base/issues"
+  },
+  "license": "MIT",
+  "author": "Kirill Fomichev <fanatid@ya.ru> (https://github.com/fanatid)",
+  "files": [
+    "index.js"
+  ],
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/crypto-browserify/hash-base.git"
+  },
+  "scripts": {
+    "coverage": "nyc node test/*.js",
+    "lint": "standard",
+    "test": "npm run lint && npm run unit",
+    "unit": "node test/*.js"
+  },
+  "dependencies": {
+    "inherits": "^2.0.1",
+    "safe-buffer": "^5.0.1"
+  },
+  "devDependencies": {
+    "nyc": "^8.3.2",
+    "standard": "*",
+    "tape": "^4.2.0"
+  },
+  "engines": {
+    "node": ">=4"
+  }
+}

package/node_modules/@meteorjs/crypto-browserify/package.json

@@ -0,0 +1,62 @@
+{
+  "author": "Dominic Tarr <dominic.tarr@gmail.com> (dominictarr.com)",
+  "name": "@meteorjs/crypto-browserify",
+  "description": "implementation of crypto for the browser",
+  "version": "3.12.1",
+  "homepage": "https://github.com/meteor-compat/crypto-browserify",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/browserify/crypto-browserify.git"
+  },
+  "scripts": {
+    "lint": "eslint --ext=js,mjs .",
+    "pretest": "npm run lint",
+    "tests-only": "tape 'test/**/*.js'",
+    "test": "npm run tests-only",
+    "posttest": "aud --production"
+  },
+  "funding": {
+    "url": "https://github.com/sponsors/ljharb"
+  },
+  "engines": {
+    "node": ">= 0.10"
+  },
+  "dependencies": {
+    "browserify-cipher": "^1.0.1",
+    "browserify-sign": "^4.2.3",
+    "create-ecdh": "^4.0.4",
+    "create-hash": "^1.2.0",
+    "create-hmac": "^1.1.7",
+    "diffie-hellman": "^5.0.3",
+    "hash-base": "~3.0.4",
+    "inherits": "^2.0.4",
+    "pbkdf2": "^3.1.2",
+    "public-encrypt": "^4.0.3",
+    "randombytes": "^2.1.0",
+    "randomfill": "^1.0.4"
+  },
+  "devDependencies": {
+    "@ljharb/eslint-config": "^21.1.0",
+    "aud": "^2.0.4",
+    "eslint": "=8.8.0",
+    "hash-test-vectors": "^1.3.2",
+    "object.entries": "^1.1.7",
+    "pseudorandombytes": "^2.0.0",
+    "safe-buffer": "^5.2.1",
+    "semver": "^6.3.1",
+    "tape": "^5.7.5"
+  },
+  "browser": {
+    "crypto": false
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/browserify/crypto-browserify/issues"
+  },
+  "main": "index.js",
+  "directories": {
+    "example": "example",
+    "test": "test"
+  }
+}

package/node_modules/@meteorjs/crypto-browserify/test/aes.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var test = require('tape');
+var bcCrypto = require('browserify-cipher/browser');
+var bcCyphers = bcCrypto.getCiphers();
+var randomBytes = require('pseudorandombytes');
+
+for (var i = 0; i < 4; i += 1) {
+	bcCrypto.listCiphers().forEach(function (cipher) {
+		test('run: ' + i, function (t) {
+			/* eslint no-loop-func: 0 */
+			t.test('ciphers: ' + cipher, function (st) {
+				st.plan(1);
+				var data = randomBytes(562);
+				var password = randomBytes(20);
+				var crypter = bcCrypto.createCipher(cipher, password);
+				var decrypter = bcCrypto.createDecipher(cipher, password);
+				var out = [];
+				out.push(decrypter.update(crypter.update(data)));
+				out.push(decrypter.update(crypter['final']()));
+				if (cipher.indexOf('gcm') > -1) {
+					decrypter.setAuthTag(crypter.getAuthTag());
+				}
+				out.push(decrypter['final']());
+
+				st.equals(data.toString('hex'), Buffer.concat(out).toString('hex'));
+			});
+		});
+	});
+}
+
+test('getCiphers', function (t) {
+	t.plan(1);
+	t.ok(bcCyphers.length, 'get ciphers returns an array');
+});
+
+test('through crypto browserify works', function (t) {
+	t.plan(2);
+	var crypto = require('../'); // eslint-disable-line global-require
+	var cipher = 'aes-128-ctr';
+	var data = randomBytes(562);
+	var password = randomBytes(20);
+	var crypter = crypto.createCipher(cipher, password);
+	var decrypter = crypto.createDecipher(cipher, password);
+	var out = [];
+	out.push(decrypter.update(crypter.update(data)));
+	out.push(decrypter.update(crypter['final']()));
+	out.push(decrypter['final']());
+
+	t.equals(data.toString('hex'), Buffer.concat(out).toString('hex'));
+
+	t.ok(crypto.getCiphers().length, 'get ciphers returns an array');
+});

package/node_modules/@meteorjs/crypto-browserify/test/create-hash.js

@@ -0,0 +1,51 @@
+'use strict';
+
+var test = require('tape');
+var satisfies = require('semver').satisfies;
+
+var algorithms = ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160'];
+var encodings = ['hex', 'base64']; // FIXME: test binary
+var vectors = require('hash-test-vectors');
+
+function runTest(name, createHash, algorithm) {
+	var isUnsupported = satisfies(process.version, '^17') && (
+		algorithm === 'rmd160'
+		|| algorithm === 'hmac(rmd160)'
+	);
+	test(
+		name + ' test ' + algorithm + ' against test vectors',
+		{ skip: isUnsupported && 'this node version does not support ' + algorithm },
+		function (t) {
+			vectors.forEach(function (obj, i) {
+				var input = new Buffer(obj.input, 'base64');
+				var node = obj[algorithm];
+				var js = createHash(algorithm).update(input).digest('hex');
+				t.equal(js, node, algorithm + '(testVector[' + i + ']) == ' + node);
+
+				encodings.forEach(function (encoding) {
+					var eInput = new Buffer(obj.input, 'base64').toString(encoding);
+					var eNode = obj[algorithm];
+					var eJS = createHash(algorithm).update(eInput, encoding).digest('hex');
+					t.equal(eJS, eNode, algorithm + '(testVector[' + i + '], ' + encoding + ') == ' + eNode);
+				});
+				input = new Buffer(obj.input, 'base64');
+				node = obj[algorithm];
+				var hash = createHash(algorithm);
+				hash.end(input);
+				js = hash.read().toString('hex');
+				t.equal(js, node, algorithm + '(testVector[' + i + ']) == ' + node);
+			});
+
+			t.end();
+		}
+	);
+}
+
+function testLib(name, createHash) {
+	algorithms.forEach(function (algorithm) {
+		runTest(name, createHash, algorithm);
+	});
+}
+
+testLib('createHash in crypto-browserify', require('../').createHash);
+testLib('create-hash/browser', require('create-hash/browser'));

package/node_modules/@meteorjs/crypto-browserify/test/create-hmac.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var test = require('tape');
+var satisfies = require('semver').satisfies;
+
+var algorithms = ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160'];
+var vectors = require('hash-test-vectors/hmac');
+
+function testLib(name, createHmac) {
+	algorithms.forEach(function (alg) {
+		var isUnsupported = satisfies(process.version, '^17') && (
+			alg === 'rmd160'
+			|| alg === 'hmac(rmd160)'
+		);
+		test(
+			name + ' hmac(' + alg + ')',
+			{ skip: isUnsupported && 'this node version does not support ' + alg },
+			function (t) {
+				vectors.forEach(function (input) {
+					var output = createHmac(alg, new Buffer(input.key, 'hex'))
+						.update(input.data, 'hex').digest();
+
+					output = input.truncate ? output.slice(0, input.truncate) : output;
+					output = output.toString('hex');
+					t.equal(output, input[alg]);
+				});
+
+				t.end();
+			}
+		);
+
+		test(
+			'hmac(' + alg + ')',
+			{ skip: isUnsupported && 'this node version does not support ' + alg },
+			function (t) {
+				vectors.forEach(function (input) {
+					var hmac = createHmac(alg, new Buffer(input.key, 'hex'));
+
+					hmac.end(input.data, 'hex');
+					var output = hmac.read();
+
+					output = input.truncate ? output.slice(0, input.truncate) : output;
+					output = output.toString('hex');
+					t.equal(output, input[alg]);
+				});
+
+				t.end();
+			}
+		);
+	});
+}
+
+testLib('createHmac in crypto-browserify', require('../').createHmac);
+testLib('create-hmac/browser', require('create-hmac/browser'));

package/node_modules/@meteorjs/crypto-browserify/test/dh.js

@@ -0,0 +1,60 @@
+'use strict';
+
+var test = require('tape');
+var crypto = require('diffie-hellman/browser');
+
+test('diffie-hellman mod groups', function (t) {
+	[
+		'modp1',
+		'modp2',
+		'modp5',
+		'modp14',
+		'modp15',
+		'modp16'
+	].forEach(function (mod) {
+		t.test(mod, function (st) {
+			st.plan(3);
+			var dh1 = crypto.getDiffieHellman(mod);
+			var p1 = dh1.getPrime().toString('hex');
+			dh1.generateKeys();
+			var dh2 = crypto.getDiffieHellman(mod);
+			var p2 = dh2.getPrime().toString('hex');
+			dh2.generateKeys();
+			st.equals(p1, p2, 'equal primes');
+			var pubk1 = dh1.getPublicKey();
+			var pubk2 = dh2.getPublicKey();
+			st.notEquals(pubk1, pubk2, 'diff public keys');
+			var pub1 = dh1.computeSecret(pubk2).toString('hex');
+			var pub2 = dh2.computeSecret(dh1.getPublicKey()).toString('hex');
+			st.equals(pub1, pub2, 'equal secrets');
+		});
+	});
+});
+
+test('diffie-hellman key lengths', function (t) {
+	[
+		64,
+		65,
+		192
+	].forEach(function (len) {
+		t.test(String(len), function (st) {
+			st.plan(3);
+			var dh2 = crypto.createDiffieHellman(len);
+			var prime2 = dh2.getPrime();
+			var p2 = prime2.toString('hex');
+			var dh1 = crypto.createDiffieHellman(prime2);
+			var p1 = dh1.getPrime().toString('hex');
+			dh1.generateKeys();
+			dh2.generateKeys();
+			st.equals(p1, p2, 'equal primes');
+
+			var pubk1 = dh1.getPublicKey();
+			var pubk2 = dh2.getPublicKey();
+			st.notEquals(pubk1, pubk2, 'diff public keys');
+
+			var pub1 = dh1.computeSecret(pubk2).toString('hex');
+			var pub2 = dh2.computeSecret(dh1.getPublicKey()).toString('hex');
+			st.equals(pub1, pub2, 'equal secrets');
+		});
+	});
+});

package/node_modules/@meteorjs/crypto-browserify/test/ecdh.js

@@ -0,0 +1,62 @@
+'use strict';
+
+var mods = [
+	'secp256k1',
+	'secp224r1',
+	'prime256v1',
+	'prime192v1'
+];
+var test = require('tape');
+var createECDH1 = require('../').createECDH;
+var createECDH2 = require('create-ecdh/browser');
+
+mods.forEach(function (mod) {
+	test('createECDH: ' + mod + ' uncompressed', function (t) {
+		t.plan(2);
+		var dh1 = createECDH1(mod);
+		dh1.generateKeys();
+		var dh2 = createECDH2(mod);
+		dh2.generateKeys();
+		var pubk1 = dh1.getPublicKey();
+		var pubk2 = dh2.getPublicKey();
+		t.notEquals(pubk1.toString('hex'), pubk2.toString('hex'), 'diff public keys');
+		var pub1 = dh1.computeSecret(pubk2).toString('hex');
+		var pub2 = dh2.computeSecret(pubk1).toString('hex');
+		t.equals(pub1, pub2, 'equal secrets');
+	});
+
+	test('createECDH: ' + mod + ' compressed', function (t) {
+		t.plan(2);
+		var dh1 = createECDH1(mod);
+		dh1.generateKeys();
+		var dh2 = createECDH2(mod);
+		dh2.generateKeys();
+		var pubk1 = dh1.getPublicKey(null, 'compressed');
+		var pubk2 = dh2.getPublicKey(null, 'compressed');
+		t.notEquals(pubk1.toString('hex'), pubk2.toString('hex'), 'diff public keys');
+		var pub1 = dh1.computeSecret(pubk2).toString('hex');
+		var pub2 = dh2.computeSecret(pubk1).toString('hex');
+		t.equals(pub1, pub2, 'equal secrets');
+	});
+
+	test('createECDH: ' + mod + ' set stuff', function (t) {
+		t.plan(5);
+		var dh1 = createECDH1(mod);
+		var dh2 = createECDH2(mod);
+		dh1.generateKeys();
+		dh2.generateKeys();
+		dh1.setPrivateKey(dh2.getPrivateKey());
+		dh1.setPublicKey(dh2.getPublicKey());
+		var priv1 = dh1.getPrivateKey('hex');
+		var priv2 = dh2.getPrivateKey('hex');
+		t.equals(priv1, priv2, 'same private key');
+		var pubk1 = dh1.getPublicKey();
+		var pubk2 = dh2.getPublicKey();
+		t.equals(pubk1.toString('hex'), pubk2.toString('hex'), 'same public keys, uncompressed');
+		t.equals(dh1.getPublicKey('hex', 'compressed'), dh2.getPublicKey('hex', 'compressed'), 'same public keys compressed');
+		t.equals(dh1.getPublicKey('hex', 'hybrid'), dh2.getPublicKey('hex', 'hybrid'), 'same public keys hybrid');
+		var pub1 = dh1.computeSecret(pubk2).toString('hex');
+		var pub2 = dh2.computeSecret(pubk1).toString('hex');
+		t.equals(pub1, pub2, 'equal secrets');
+	});
+});

package/node_modules/@meteorjs/crypto-browserify/test/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+/* eslint-disable global-require */
+
+require('./create-hash');
+require('./create-hmac');
+if (!process.browser) {
+	require('./dh');
+}
+
+require('./pbkdf2');
+try {
+	require('randombytes')(8);
+	require('./ecdh');
+	require('./public-encrypt');
+	require('./random-bytes');
+	require('./sign');
+	require('./random-fill');
+} catch (e) {
+	console.log('no secure rng avaiable');
+}
+require('./aes');