argon2 - npm Package Compare versions

Comparing version 0.6.0 to 0.7.0

index.js

@@ -1,5 +0,5 @@
-var bindings = require('bindings')('argon2'),
-  crypto = require('crypto');
+const bindings = require('bindings')('argon2');
+const crypto = require('crypto');
 
-var defaults = exports.defaults = Object.freeze({
+const defaults = Object.freeze({
   timeCost: 3,
@@ -11,9 +11,11 @@ memoryCost: 12,
 
-var fail = function (message, callback) {
-  var error = new Error(message);
+const fail = (message, callback) => {
+  'use strict';
 
-  if (typeof(callback) === 'undefined') {
+  const error = new Error(message);
+
+  if (typeof callback === 'undefined') {
     throw error;
   } else {
-    process.nextTick(function () {
+    process.nextTick(() => {
       callback(error, null);
@@ -24,9 +26,11 @@ });
 
-var validate = function (salt, options, callback) {
-  if (salt.length > 16) {
-    fail('Salt too long, maximum 16 characters.', callback);
+const validate = (salt, options, callback) => {
+  'use strict';
+
+  if (salt.length !== 16) {
+    fail('Invalid salt length, must be 16 bytes.', callback);
     return false;
   }
 
-  for (var key in defaults) {
+  for (const key of Object.keys(defaults)) {
     options[key] = options[key] || defaults[key];
@@ -73,54 +77,63 @@ }
 
-exports.hash = function (plain, salt, options, callback) {
-  'use strict';
+module.exports = {
+  defaults,
 
-  if (!callback) {
-    callback = options;
-    options = defaults;
-  }
+  hash (plain, salt, options, callback) {
+    'use strict';
 
-  options = Object.assign({}, options);
+    if (!Buffer.isBuffer(salt)) {
+      salt = new Buffer(salt);
+    }
 
-  if (validate(salt, options, callback)) {
-    return bindings.hash(plain, salt, options.timeCost, options.memoryCost,
-      options.parallelism, options.argon2d, callback);
-  }
-};
+    if (!callback) {
+      callback = options;
+      options = defaults;
+    }
 
-exports.hashSync = function (plain, salt, options) {
-  'use strict';
+    options = Object.assign({}, options);
 
-  options = Object.assign({}, options || defaults);
+    if (validate(salt, options, callback)) {
+      return bindings.hash(plain, salt, options.timeCost, options.memoryCost,
+        options.parallelism, options.argon2d, callback);
+    }
+  },
 
-  if (validate(salt, options)) {
-    return bindings.hashSync(plain, salt, options.timeCost, options.memoryCost,
-        options.parallelism, options.argon2d);
-  }
-};
+  hashSync (plain, salt, options) {
+    'use strict';
 
-exports.generateSalt = function (callback) {
-  'use strict';
+    if (!Buffer.isBuffer(salt)) {
+      salt = new Buffer(salt);
+    }
 
-  crypto.randomBytes(16, function (err, buffer) {
-    callback(err, buffer.toString());
-  });
-};
+    options = Object.assign({}, options || defaults);
 
-exports.generateSaltSync = function () {
-  'use strict';
+    if (validate(salt, options)) {
+      return bindings.hashSync(plain, salt, options.timeCost,
+        options.memoryCost, options.parallelism, options.argon2d);
+    }
+  },
 
-  return crypto.randomBytes(16).toString();
-};
+  generateSalt (callback) {
+    'use strict';
 
-exports.verify = function (hash, plain, callback) {
-  'use strict';
+    return crypto.randomBytes(16, callback);
+  },
 
-  return bindings.verify(hash, plain, /argon2d/.test(hash), callback);
-};
+  generateSaltSync () {
+    'use strict';
 
-exports.verifySync = function (hash, plain) {
-  'use strict';
+    return crypto.randomBytes(16);
+  },
 
-  return bindings.verifySync(hash, plain, /argon2d/.test(hash));
+  verify (hash, plain, callback) {
+    'use strict';
+
+    return bindings.verify(hash, plain, /argon2d/.test(hash), callback);
+  },
+
+  verifySync (hash, plain) {
+    'use strict';
+
+    return bindings.verifySync(hash, plain, /argon2d/.test(hash));
+  }
 };
-

package.json

 {
   "name": "argon2",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "An Argon2 library for Node",
@@ -5,0 +5,0 @@ "main": "index.js",

README.md

@@ -1,2 +0,2 @@
-# node-argon2 [![NPM package][npm-image]][npm-url] [![Build status][travis-image]][travis-url] [![Coverage status][coverage-image]][coverage-url] [![Code Climate][codeclimate-image]][codeclimate-url] [![Dependencies][david-dm-image]][david-dm-url]
+# node-argon2 [![NPM package][npm-image]][npm-url] [![Build status][travis-image]][travis-url] [![Coverage status][coverage-image]][coverage-url] [![Code Quality][codequality-image]][codequality-url] [![Dependencies][david-dm-image]][david-dm-url]
 Bindings to the  reference [Argon2](https://github.com/P-H-C/phc-winner-argon2)
@@ -12,3 +12,5 @@ implementation.
 and async, and to verify if a password matches a hash, and also generate random
-cryptographically-safe salts.
+cryptographically-safe salts. Salts **must** be exactly 16-byte long buffers
+but strings will automatically be converted (this is **deprecated** and should
+NOT be relied upon).
 
@@ -29,3 +31,3 @@ To hash a password:
 try {
-  var hash = argon2.hashSync('password', 'somesalt');
+  var hash = argon2.hashSync('password', 'somesaltwith16ch');
 } catch (err) {
@@ -50,3 +52,3 @@ console.log(err);
 try {
-  var hash = argon2.hashSync('password', 'somesalt', {
+  var hash = argon2.hashSync('password', 'somesaltwith16ch', {
     argon2d: true
@@ -136,5 +138,5 @@ });
 [coverage-url]: https://coveralls.io/github/ranisalt/node-argon2
-[codeclimate-image]: https://img.shields.io/codeclimate/github/ranisalt/node-argon2.svg?style=flat-square
-[codeclimate-url]: https://codeclimate.com/github/ranisalt/node-argon2
+[codequality-image]: https://img.shields.io/codacy/15927f4eb15747fd8a537e48a04bd4f6/master.svg?style=flat-square
+[codequality-url]: https://www.codacy.com/app/ranisalt/node-argon2
 [david-dm-image]: https://img.shields.io/david/ranisalt/node-argon2.svg?style=flat-square
 [david-dm-url]: https://david-dm.org/ranisalt/node-argon2

test.spec.js

@@ -1,7 +0,11 @@
-var argon2 = process.env.COVERAGE
+const argon2 = process.env.COVERAGE
   ? require('./index-cov')
   : require('./index');
 
+const password = 'password';
+const salt = new Buffer(16);
+salt.fill(0).write('somesalt');
+
 module.exports = {
-  test_defaults(assert) {
+  testDefaults  (assert) {
     'use strict';
@@ -20,3 +24,3 @@
 
-  test_hash(assert) {
+  testHash  (assert) {
     'use strict';
@@ -26,3 +30,3 @@
 
-    argon2.hash('password', 'somesalt', function (err, hash) {
+    argon2.hash(password, salt, (err, hash) => {
       assert.ok(hash, 'Hash should be defined.');
@@ -35,3 +39,3 @@ assert.equal(hash, '$argon2i$m=4096,t=3,p=1$c29tZXNhbHQAAAAAAAAAAA$FHF/OZ0GJpMRAlBmPTqXxw36Ftp87JllALZPcP9w9gs');
 
-  test_hash_argon2d(assert) {
+  testHashArgon2d (assert) {
     'use strict';
@@ -41,5 +45,5 @@
 
-    argon2.hash('password', 'somesalt', {
+    argon2.hash(password, salt, {
       argon2d: true
-    }, function (err, hash) {
+    }, (err, hash) => {
       assert.ok(hash, 'Hash should be defined.');
@@ -52,3 +56,3 @@ assert.ok(/\$argon2d\$/.test(hash), 'Should have argon2d signature.');
 
-  test_hash_truthy_argon2d(assert) {
+  testHashTruthyArgon2d (assert) {
     'use strict';
@@ -58,5 +62,5 @@
 
-    argon2.hash('password', 'somesalt', {
+    argon2.hash(password, salt, {
       argon2d: 'foo'
-    }, function (err, hash) {
+    }, (err, hash) => {
       assert.ok(hash, 'Hash should be defined.');
@@ -69,3 +73,3 @@ assert.ok(/\$argon2d\$/.test(hash), 'Should have argon2d signature.');
 
-  test_hash_falsy_argon2d(assert) {
+  testHashFalsyArgon2d (assert) {
     'use strict';
@@ -75,5 +79,5 @@
 
-    argon2.hash('password', 'somesalt', {
+    argon2.hash(password, salt, {
       argon2d: ''
-    }, function (err, hash) {
+    }, (err, hash) => {
       assert.ok(hash, 'Hash should be defined.');
@@ -86,3 +90,3 @@ assert.ok(/\$argon2i\$/.test(hash), 'Should not have argon2d signature.');
 
-  test_hash_long_salt(assert) {
+  testHashLongSalt (assert) {
     'use strict';
@@ -92,5 +96,5 @@
 
-    argon2.hash('password', 'somesaltwaytoobig', function (err, hash) {
+    argon2.hash(password, 'somesaltwaytoobig', (err, hash) => {
       assert.ok(err, 'Error should be defined.');
-      assert.equal(err.message, 'Salt too long, maximum 16 characters.');
+      assert.equal(err.message, 'Invalid salt length, must be 16 bytes.');
       assert.equal(undefined, hash);
@@ -101,3 +105,3 @@ assert.done();
 
-  test_hash_time_cost(assert) {
+  testHashTimeCost (assert) {
     'use strict';
@@ -107,5 +111,5 @@
 
-    argon2.hash('password', 'somesalt', {
+    argon2.hash(password, salt, {
       timeCost: 4
-    }, function (err, hash) {
+    }, (err, hash) => {
       assert.ok(hash, 'Hash should be defined.');
@@ -118,3 +122,3 @@ assert.ok(/t=4/.test(hash), 'Should have correct time cost.');
 
-  test_hash_invalid_time_cost(assert) {
+  testHashInvalidTimeCost (assert) {
     'use strict';
@@ -124,5 +128,5 @@
 
-    argon2.hash('password', 'somesalt', {
+    argon2.hash(password, salt, {
       timeCost: 'foo'
-    }, function (err, hash) {
+    }, (err, hash) => {
       assert.ok(err, 'Error should be defined.');
@@ -135,3 +139,3 @@ assert.equal(err.message, 'Invalid time cost, must be a number.');
 
-  test_hash_low_time_cost(assert) {
+  testHashLowTimeCost (assert) {
     'use strict';
@@ -141,5 +145,5 @@
 
-    argon2.hash('password', 'somesalt', {
+    argon2.hash(password, salt, {
       timeCost: -4294967290
-    }, function (err, hash) {
+    }, (err, hash) => {
       assert.ok(err, 'Error should be defined.');
@@ -152,3 +156,3 @@ assert.equal(err.message, 'Time cost too low, minimum of 1.');
 
-  test_hash_high_time_cost(assert) {
+  testHashHighTimeCost (assert) {
     'use strict';
@@ -158,5 +162,5 @@
 
-    argon2.hash('password', 'somesalt', {
+    argon2.hash(password, salt, {
       timeCost: 4294967297
-    }, function (err, hash) {
+    }, (err, hash) => {
       assert.ok(err, 'Error should be defined.');
@@ -169,3 +173,3 @@ assert.equal(err.message, 'Time cost too high, maximum of 4294967295.');
 
-  test_hash_memory_cost(assert) {
+  testHashMemoryCost (assert) {
     'use strict';
@@ -175,5 +179,5 @@
 
-    argon2.hash('password', 'somesalt', {
+    argon2.hash(password, salt, {
       memoryCost: 13
-    }, function (err, hash) {
+    }, (err, hash) => {
       assert.ok(hash, 'Hash should be defined.');
@@ -186,3 +190,3 @@ assert.ok(/m=8192/.test(hash), 'Should have correct memory cost.');
 
-  test_hash_invalid_memory_cost(assert) {
+  testHashInvalidMemoryCost (assert) {
     'use strict';
@@ -192,5 +196,5 @@
 
-    argon2.hash('password', 'somesalt', {
+    argon2.hash(password, salt, {
       memoryCost: 'foo'
-    }, function (err, hash) {
+    }, (err, hash) => {
       assert.ok(err, 'Error should be defined.');
@@ -203,3 +207,3 @@ assert.equal(err.message, 'Invalid memory cost, must be a number.');
 
-  test_hash_low_memory_cost(assert) {
+  testHashLowMemoryCost (assert) {
     'use strict';
@@ -209,5 +213,5 @@
 
-    argon2.hash('password', 'somesalt', {
+    argon2.hash(password, salt, {
       memoryCost: -4294967290
-    }, function (err, hash) {
+    }, (err, hash) => {
       assert.ok(err, 'Error should be defined.');
@@ -220,3 +224,3 @@ assert.equal(err.message, 'Memory cost too low, minimum of 1.');
 
-  test_hash_high_memory_cost(assert) {
+  testHashHighMemoryCost (assert) {
     'use strict';
@@ -226,5 +230,5 @@
 
-    argon2.hash('password', 'somesalt', {
+    argon2.hash(password, salt, {
       memoryCost: 32
-    }, function (err, hash) {
+    }, (err, hash) => {
       assert.ok(err, 'Error should be defined.');
@@ -237,3 +241,3 @@ assert.equal(err.message, 'Memory cost too high, maximum of 31.');
 
-  test_hash_parallelism(assert) {
+  testHashParallelism (assert) {
     'use strict';
@@ -243,5 +247,5 @@
 
-    argon2.hash('password', 'somesalt', {
+    argon2.hash(password, salt, {
       parallelism: 2
-    }, function (err, hash) {
+    }, (err, hash) => {
       assert.ok(hash, 'Hash should be defined.');
@@ -254,3 +258,3 @@ assert.ok(/p=2/.test(hash), 'Should have correct parallelism.');
 
-  test_hash_invalid_parallelism(assert) {
+  testHashInvalidParallelism (assert) {
     'use strict';
@@ -260,5 +264,5 @@
 
-    argon2.hash('password', 'somesalt', {
+    argon2.hash(password, salt, {
       parallelism: 'foo'
-    }, function (err, hash) {
+    }, (err, hash) => {
       assert.ok(err, 'Error should be defined.');
@@ -271,3 +275,3 @@ assert.equal(err.message, 'Invalid parallelism, must be a number.');
 
-  test_hash_low_parallelism(assert) {
+  testHashLowParallelism (assert) {
     'use strict';
@@ -277,5 +281,5 @@
 
-    argon2.hash('password', 'somesalt', {
+    argon2.hash(password, salt, {
       parallelism: -4294967290
-    }, function (err, hash) {
+    }, (err, hash) => {
       assert.ok(err, 'Error should be defined.');
@@ -288,3 +292,3 @@ assert.equal(err.message, 'Parallelism too low, minimum of 1.');
 
-  test_hash_high_parallelism(assert) {
+  testHashHighParallelism (assert) {
     'use strict';
@@ -294,5 +298,5 @@
 
-    argon2.hash('password', 'somesalt', {
+    argon2.hash(password, salt, {
       parallelism: 4294967297
-    }, function (err, hash) {
+    }, (err, hash) => {
       assert.ok(err, 'Error should be defined.');
@@ -305,3 +309,3 @@ assert.equal(err.message, 'Parallelism too high, maximum of 4294967295.');
 
-  test_hash_all_options(assert) {
+  testHashAllOptions (assert) {
     'use strict';
@@ -311,7 +315,7 @@
 
-    argon2.hash('password', 'somesalt', {
+    argon2.hash(password, salt, {
       timeCost: 4,
       memoryCost: 13,
       parallelism: 2
-    }, function (err, hash) {
+    }, (err, hash) => {
       assert.ok(hash, 'Hash should be defined.');
@@ -324,3 +328,3 @@ assert.ok(/m=8192,t=4,p=2/.test(hash), 'Should have correct options.');
 
-  test_hash_sync(assert) {
+  testHashSync (assert) {
     'use strict';
@@ -330,3 +334,3 @@
 
-    var hash = argon2.hashSync('password', 'somesalt');
+    const hash = argon2.hashSync(password, salt);
     assert.equal(hash, '$argon2i$m=4096,t=3,p=1$c29tZXNhbHQAAAAAAAAAAA$FHF/OZ0GJpMRAlBmPTqXxw36Ftp87JllALZPcP9w9gs');
@@ -336,3 +340,3 @@ assert.done();
 
-  test_hash_argon2d_sync(assert) {
+  testHashArgon2dSync (assert) {
     'use strict';
@@ -342,3 +346,3 @@
 
-    var hash = argon2.hashSync('password', 'somesalt', {
+    const hash = argon2.hashSync(password, salt, {
       argon2d: true
@@ -350,3 +354,3 @@ });
 
-  test_hash_truthy_argon2d_sync(assert) {
+  testHashTruthyArgon2dSync (assert) {
     'use strict';
@@ -356,3 +360,3 @@
 
-    var hash = argon2.hashSync('password', 'somesalt', {
+    const hash = argon2.hashSync(password, salt, {
       argon2d: 'foo'
@@ -364,3 +368,3 @@ });
 
-  test_hash_falsy_argon2d_sync(assert) {
+  testHashFalsyArgon2dSync (assert) {
     'use strict';
@@ -370,3 +374,3 @@
 
-    var hash = argon2.hashSync('password', 'somesalt', {
+    const hash = argon2.hashSync(password, salt, {
       argon2d: ''
@@ -378,3 +382,3 @@ });
 
-  test_hash_sync_time_cost(assert) {
+  testHashSyncTimeCost (assert) {
     'use strict';
@@ -384,3 +388,3 @@
 
-    var hash = argon2.hashSync('password', 'somesalt', {
+    const hash = argon2.hashSync(password, salt, {
       timeCost: 4
@@ -392,3 +396,3 @@ });
 
-  test_hash_sync_invalid_time_cost(assert) {
+  testHashSyncInvalidTimeCost (assert) {
     'use strict';
@@ -398,4 +402,4 @@
 
-    assert.throws(function () {
-      var hash = argon2.hashSync('password', 'somesalt', {
+    assert.throws(() => {
+      argon2.hashSync(password, salt, {
         timeCost: 'foo'
@@ -407,3 +411,3 @@ });
 
-  test_hash_sync_low_time_cost(assert) {
+  testHashSyncLowTimeCost (assert) {
     'use strict';
@@ -413,4 +417,4 @@
 
-    assert.throws(function () {
-      var hash = argon2.hashSync('password', 'somesalt', {
+    assert.throws(() => {
+      argon2.hashSync(password, salt, {
         timeCost: -4294967290
@@ -422,3 +426,3 @@ });
 
-  test_hash_sync_high_time_cost(assert) {
+  testHashSyncHighTimeCost (assert) {
     'use strict';
@@ -428,4 +432,4 @@
 
-    assert.throws(function () {
-      var hash = argon2.hashSync('password', 'somesalt', {
+    assert.throws(() => {
+      argon2.hashSync(password, salt, {
         timeCost: 4294967297
@@ -437,3 +441,3 @@ });
 
-  test_hash_sync_memory_cost(assert) {
+  testHashSyncMemoryCost (assert) {
     'use strict';
@@ -443,3 +447,3 @@
 
-    var hash = argon2.hashSync('password', 'somesalt', {
+    const hash = argon2.hashSync(password, salt, {
       memoryCost: 13
@@ -451,3 +455,3 @@ });
 
-  test_hash_sync_invalid_memory_cost(assert) {
+  testHashSyncInvalidMemoryCost (assert) {
     'use strict';
@@ -457,4 +461,4 @@
 
-    assert.throws(function () {
-      var hash = argon2.hashSync('password', 'somesalt', {
+    assert.throws(() => {
+      argon2.hashSync(password, salt, {
         memoryCost: 'foo'
@@ -466,3 +470,3 @@ });
 
-  test_hash_sync_low_memory_cost(assert) {
+  testHashSyncLowMemoryCost (assert) {
     'use strict';
@@ -472,4 +476,4 @@
 
-    assert.throws(function () {
-      var hash = argon2.hashSync('password', 'somesalt', {
+    assert.throws(() => {
+      argon2.hashSync(password, salt, {
         memoryCost: -4294967290
@@ -481,3 +485,3 @@ });
 
-  test_hash_sync_high_memory_cost(assert) {
+  testHashSyncHighMemoryCost (assert) {
     'use strict';
@@ -487,4 +491,4 @@
 
-    assert.throws(function () {
-      argon2.hashSync('password', 'somesalt', {
+    assert.throws(() => {
+      argon2.hashSync(password, salt, {
         memoryCost: 32
@@ -496,3 +500,3 @@ });
 
-  test_hash_sync_parallelism(assert) {
+  testHashSyncParallelism (assert) {
     'use strict';
@@ -502,3 +506,3 @@
 
-    var hash = argon2.hashSync('password', 'somesalt', {
+    const hash = argon2.hashSync(password, salt, {
       parallelism: 2
@@ -510,3 +514,3 @@ });
 
-  test_hash_sync_invalid_parallelism(assert) {
+  testHashSyncInvalidParallelism (assert) {
     'use strict';
@@ -516,4 +520,4 @@
 
-    assert.throws(function () {
-      var hash = argon2.hashSync('password', 'somesalt', {
+    assert.throws(() => {
+      argon2.hashSync(password, salt, {
         parallelism: 'foo'
@@ -525,3 +529,3 @@ });
 
-  test_hash_sync_low_parallelism(assert) {
+  testHashSyncLowParallelism (assert) {
     'use strict';
@@ -531,4 +535,4 @@
 
-    assert.throws(function () {
-      var hash = argon2.hashSync('password', 'somesalt', {
+    assert.throws(() => {
+      argon2.hashSync(password, salt, {
         parallelism: -4294967290
@@ -540,3 +544,3 @@ });
 
-  test_hash_sync_high_parallelism(assert) {
+  testHashSyncHighParallelism (assert) {
     'use strict';
@@ -546,4 +550,4 @@
 
-    assert.throws(function () {
-      var hash = argon2.hashSync('password', 'somesalt', {
+    assert.throws(() => {
+      argon2.hashSync(password, salt, {
         parallelism: 4294967297
@@ -555,3 +559,3 @@ });
 
-  test_hash_sync_all_options(assert) {
+  testHashSyncAllOptions (assert) {
     'use strict';
@@ -561,3 +565,3 @@
 
-    var hash = argon2.hashSync('password', 'somesalt', {
+    const hash = argon2.hashSync(password, salt, {
       timeCost: 4,
@@ -571,3 +575,3 @@ memoryCost: 13,
 
-  test_hash_sync_long_salt(assert) {
+  testHashSyncLongSalt (assert) {
     'use strict';
@@ -577,4 +581,4 @@
 
-    assert.throws(function () {
-      argon2.hashSync('password', 'somesaltwaytoobig');
+    assert.throws(() => {
+      argon2.hashSync(password, 'somesaltwaytoobig');
     });
@@ -584,3 +588,3 @@ assert.done();
 
-  test_generate_salt(assert) {
+  testGenerateSalt (assert) {
     'use strict';
@@ -590,3 +594,3 @@
 
-    argon2.generateSalt(function (err, salt) {
+    argon2.generateSalt((err, salt) => {
       assert.ok(salt.length <= 16);
@@ -597,3 +601,3 @@ assert.done();
 
-  test_generate_salt_sync(assert) {
+  testGenerateSaltSync (assert) {
     'use strict';
@@ -607,3 +611,3 @@
 
-  test_verify_ok(assert) {
+  testVerifyOk (assert) {
     'use strict';
@@ -613,4 +617,4 @@
 
-    argon2.verify(argon2.hashSync('password', argon2.generateSaltSync()),
-      'password', function (err) {
+    argon2.verify(argon2.hashSync(password, argon2.generateSaltSync()),
+      password, (err) => {
         assert.equal(undefined, err);
@@ -621,3 +625,3 @@ assert.done();
 
-  test_verify_fail(assert) {
+  testVerifyFail (assert) {
     'use strict';
@@ -627,4 +631,4 @@
 
-    argon2.verify(argon2.hashSync('password', argon2.generateSaltSync()),
-      'passwolrd', function (err) {
+    argon2.verify(argon2.hashSync(password, argon2.generateSaltSync()),
+      'passwolrd', (err) => {
         assert.ok(err, 'Error should be defined.');
@@ -635,3 +639,3 @@ assert.done();
 
-  test_verify_argon2d_ok(assert) {
+  testVerifyArgon2dOk (assert) {
     'use strict';
@@ -641,6 +645,6 @@
 
-    argon2.hash('password', argon2.generateSaltSync(), {
+    argon2.hash(password, argon2.generateSaltSync(), {
       argon2d: true
-    }, function (err, hash) {
-      argon2.verify(hash, 'password', function (err) {
+    }, (err, hash) => {
+      argon2.verify(hash, password, (err) => {
         assert.equal(undefined, err);
@@ -652,3 +656,3 @@ assert.done();
 
-  test_verify_argon2d_fail(assert) {
+  testVerifyArgon2dFail (assert) {
     'use strict';
@@ -658,6 +662,6 @@
 
-    argon2.hash('password', argon2.generateSaltSync(), {
+    argon2.hash(password, argon2.generateSaltSync(), {
       argon2d: true
-    }, function (err, hash) {
-      argon2.verify(hash, 'passwolrd', function (err) {
+    }, (err, hash) => {
+      argon2.verify(hash, 'passwolrd', (err) => {
         assert.ok(err, 'Error should be defined.');
@@ -669,3 +673,3 @@ assert.done();
 
-  test_verify_sync_ok(assert) {
+  testVerifySyncOk (assert) {
     'use strict';
@@ -675,8 +679,8 @@
 
-    assert.equal(true, argon2.verifySync(argon2.hashSync('password',
-      argon2.generateSaltSync()), 'password'));
+    assert.equal(true, argon2.verifySync(argon2.hashSync(password,
+      argon2.generateSaltSync()), password));
     assert.done();
   },
 
-  test_verify_sync_fail(assert) {
+  testVerifySyncFail (assert) {
     'use strict';
@@ -686,3 +690,3 @@
 
-    assert.equal(false, argon2.verifySync(argon2.hashSync('password',
+    assert.equal(false, argon2.verifySync(argon2.hashSync(password,
       argon2.generateSaltSync()), 'passworld'));
@@ -692,3 +696,3 @@ assert.done();
 
-  test_verify_argon2d_sync_ok(assert) {
+  testVerifyArgon2dSyncOk (assert) {
     'use strict';
@@ -698,6 +702,6 @@
 
-    argon2.hash('password', argon2.generateSaltSync(), {
+    argon2.hash(password, argon2.generateSaltSync(), {
       argon2d: true
-    }, function (err, hash) {
-      assert.equal(true, argon2.verifySync(hash, 'password'));
+    }, (err, hash) => {
+      assert.equal(true, argon2.verifySync(hash, password));
       assert.done();
@@ -707,3 +711,3 @@ });
 
-  test_verify_argon2d_sync_fail(assert) {
+  testVerifyArgon2dSyncFail (assert) {
     'use strict';
@@ -713,5 +717,5 @@
 
-    argon2.hash('password', argon2.generateSaltSync(), {
+    argon2.hash(password, argon2.generateSaltSync(), {
       argon2d: true
-    }, function (err, hash) {
+    }, (err, hash) => {
       assert.equal(false, argon2.verifySync(hash, 'passwolrd'));
@@ -718,0 +722,0 @@ assert.done();

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Lines of code

599

increased by2.04%

Number of lines in readme file

139

increased by1.46%

Worsened metrics

Total package byte prevSize

170695

decreased by-0.21%

No dependency changes