Add new way of calling function, supporting "p"

Author: dchest

Diff for: LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2013-2014 Dmitry Chestnykh. All rights reserved.
+Copyright (c) 2013-2016 Dmitry Chestnykh. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are

Diff for: README.md

@@ -35,7 +35,9 @@ such as <https://github.com/YuzuJS/setImmediate>.
 Usage
 -----
 
-### scrypt(password, salt, logN, r, dkLen, [interruptStep], callback, [encoding])
+### Modern API
+
+#### scrypt(password, salt, options, callback)
 
 Derives a key from password and salt and calls callback
 with derived key as the only argument.
@@ -47,22 +49,53 @@ after the calculation, avoiding setImmediate.
 
 #### Arguments:
 
-* *password* - password (string or array of bytes)
-* *salt* - salt (string or array of bytes)
-* *logN* - CPU/memory cost parameter (1 to 31)
-* *r* - block size parameter
-* *dkLen* - length of derived key
-* *interruptStep* - (optional) steps to split calculation with timeouts (defaults to 1000)
-* *callback* - callback function (`function (array|string)`)
-* *encoding* - (optional) result encoding (`"base64"`, `"hex"`, or `null`/`undefined`).
+* *password* — password (`string` or `Array` of bytes or `Uint8Array`)
+* *salt* — salt (`string` or `Array` of bytes or `Uint8Array`)
+* *options* — object with key derivation options
+* *callback* — callback function receiving result (`function (Array|string)`)
 
-When encoding is not set, the result is an `Array` of bytes.
+##### Options:
+
+* `N` — CPU/memory cost parameter (must be power of two;
+  alternatively, you can specify `logN` where *N = 2^logN*).
+* `r` — block size parameter
+* `p` — parallelization parameter (default is 1)
+* `dkLen` — derived key length (default is 32)
+* `interruptStep` — (optional) steps to split calculation with timeouts (defaults to 1000)
+* `encoding` — (optional) result encoding `'base64'` or `'hex'` (result with be a `string`), or undefined (result will be an `Array` of bytes).
+
+#### Example:
+
+```javascript
+scrypt('mypassword', 'saltysalt', {
+    N: 16384,
+    r: 8,
+    p: 1,
+    dkLen: 16,
+    encoding: 'hex'
+}, function(derivedKey) {
+    console.log(derivedKey); // "5012b74fca8ec8a4a0a62ffdeeee959d"
+});
+```
 
+### Legacy API (deprecated)
 
-Limitation
-----------
+#### scrypt(password, salt, logN, r, dkLen, [interruptStep], callback, [encoding])
 
-Doesn't support parallelization parameter greater than 1.
+Legacy API doesn't support parallelization parameter greater than 1.
+
+##### Arguments:
+
+* *password* — password (string or array of bytes)
+* *salt* — salt (string or array of bytes)
+* *logN* — CPU/memory cost parameter (1 to 31)
+* *r* — block size parameter
+* *dkLen* — length of derived key
+* *interruptStep* — (optional) steps to split calculation with timeouts (defaults to 1000)
+* *callback* — callback function receiving result (`function (Array|string)`)
+* *encoding* — (optional) result encoding (`'base64'`, `'hex'`, or undefined).
+
+When encoding is not set, the result is an `Array` of bytes.
 
 
 License

Diff for: scrypt-async.js

@@ -1,15 +1,29 @@
 /*!
  * Fast "async" scrypt implementation in JavaScript.
- * Copyright (c) 2013-2015 Dmitry Chestnykh | BSD License
+ * Copyright (c) 2013-2016 Dmitry Chestnykh | BSD License
  * https://github.com/dchest/scrypt-async-js
  */
 
-/*
- * Limitation: doesn't support parallelization parameter greater than 1.
- */
-
 /**
- * scrypt(password, salt, logN, r, dkLen, [interruptStep], callback, [encoding])
+ * scrypt(password, salt, options, callback)
+ *
+ * where
+ *
+ * password and salt are strings or arrays of bytes (Array of Uint8Array)
+ * options is
+ *
+ * {
+ *    N:      // CPU/memory cost parameter, must be power of two
+ *            // (alternatively, you can specify logN)
+ *    r:      // block size
+ *    p:      // parallelization parameter
+ *    dkLen:  // length of derived key, default = 32
+ *    encoding: // optional encoding:
+ *                    "base64" - standard Base64 encoding
+ *                    "hex" — hex encoding,
+ *                    undefined/null - Array of bytes
+ *    interruptStep: // optional, steps to split calculations (default is 0)
+ * }
  *
  * Derives a key from password and salt and calls callback
  * with derived key as the only argument.
@@ -19,14 +33,9 @@
  * given, it defaults to 1000. If it's zero, the callback is called immediately
  * after the calculation, avoiding setImmediate.
  *
- * @param {string|Array.<number>} password Password.
- * @param {string|Array.<number>} salt Salt.
- * @param {number}  logN  CPU/memory cost parameter (1 to 31).
- * @param {number}  r     Block size parameter.
- * @param {number}  dkLen Length of derived key.
- * @param {number?} interruptStep (optional) Steps to split calculation with timeouts (default 1000).
- * @param {function(string|Array.<number>)} callback Callback function.
- * @param {string?} encoding (optional) Result encoding ("base64", "hex", or null).
+ * Legacy way (only supports p = 1) to call this function is:
+ *
+ * scrypt(password, salt, logN, r, dkLen, [interruptStep], callback, [encoding])
  *
  */
 function scrypt(password, salt, logN, r, dkLen, interruptStep, callback, encoding) {
@@ -347,20 +356,53 @@ function scrypt(password, salt, logN, r, dkLen, interruptStep, callback, encodin
 
   // Generate key.
 
-  // Set parallelization parameter to 1.
-  var p = 1;
+  var MAX_UINT = (-1)>>>0,
+      p = 1;
+
+  if (typeof logN === "object") {
+    // Called as: scrypt(password, salt, opts, callback)
+    if (arguments.count > 4) {
+      throw new Error('scrypt: incorrect number of arguments');
+    }
+
+    var opts = logN;
+
+    callback = r;
+    logN = opts.logN;
+    if (typeof logN === 'undefined') {
+      if (typeof opts.N !== 'undefined') {
+        if (opts.N < 0 || opts.N > MAX_UINT)
+          throw new Error('scrypt: N is out of range');
+
+        if (opts.N & (opts.N - 1) !== 0)
+          throw new Error('scrypt: N is not a power of 2');
+
+        logN = Math.log(opts.N) / Math.LN2;
+      } else {
+        throw new Error('scrypt: missing N parameter');
+      }
+    }
+    p = opts.p || 1;
+    r = opts.r;
+    dkLen = opts.dkLen || 32;
+    interruptStep = opts.interruptStep || 0;
+    encoding = opts.encoding;
+  }
+
+  if (p < 1)
+    throw new Error('scrypt: invalid p');
 
   if (r <= 0)
     throw new Error('scrypt: invalid r');
 
   if (logN < 1 || logN > 31)
     throw new Error('scrypt: logN not be between 1 and 31');
 
-  var MAX_INT = (1<<31)>>>0,
-      N = (1<<logN)>>>0,
+
+  var N = (1<<logN)>>>0,
       XY, V, B, tmp;
 
-  if (r*p >= 1<<30 || r > MAX_INT/128/p || r > MAX_INT/256 || N > MAX_INT/128/r)
+  if (r*p >= 1<<30 || r > MAX_UINT/128/p || r > MAX_UINT/256 || N > MAX_UINT/128/r)
     throw new Error('scrypt: parameters are too large');
 
   // Decode strings.
@@ -383,9 +425,9 @@ function scrypt(password, salt, logN, r, dkLen, interruptStep, callback, encodin
 
   var xi = 0, yi = 32 * r;
 
-  function smixStart() {
+  function smixStart(pos) {
     for (var i = 0; i < 32*r; i++) {
-      var j = i*4;
+      var j = pos + i*4;
       XY[xi+i] = ((B[j+3] & 0xff)<<24) | ((B[j+2] & 0xff)<<16) |
                  ((B[j+1] & 0xff)<<8)  | ((B[j+0] & 0xff)<<0);
     }
@@ -413,13 +455,13 @@ function scrypt(password, salt, logN, r, dkLen, interruptStep, callback, encodin
     }
   }
 
-  function smixFinish() {
+  function smixFinish(pos) {
     for (var i = 0; i < 32*r; i++) {
       var j = XY[xi+i];
-      B[i*4+0] = (j>>>0)  & 0xff;
-      B[i*4+1] = (j>>>8)  & 0xff;
-      B[i*4+2] = (j>>>16) & 0xff;
-      B[i*4+3] = (j>>>24) & 0xff;
+      B[pos + i*4 + 0] = (j>>>0)  & 0xff;
+      B[pos + i*4 + 1] = (j>>>8)  & 0xff;
+      B[pos + i*4 + 2] = (j>>>16) & 0xff;
+      B[pos + i*4 + 3] = (j>>>24) & 0xff;
     }
   }
 
@@ -448,6 +490,32 @@ function scrypt(password, salt, logN, r, dkLen, interruptStep, callback, encodin
         return result;
   }
 
+  // Blocking variant.
+  function calculateSync() {
+    for (var i = 0; i < p; i++) {
+      smixStart(i*128*r);
+      smixStep1(0, N);
+      smixStep2(0, N);
+      smixFinish(i*128*r);
+    }
+    callback(getResult(encoding));
+  }
+
+  // Async variant.
+  function calculateAsync(i) {
+      smixStart(i*128*r);
+      interruptedFor(0, N, interruptStep*2, smixStep1, function() {
+        interruptedFor(0, N, interruptStep*2, smixStep2, function () {
+          smixFinish(i*128*r);
+          if (i + 1 < p) {
+            nextTick(function() { calculateAsync(i + 1); });
+          } else {
+            callback(getResult(encoding));
+          }
+        });
+      });
+  }
+
   if (typeof interruptStep === 'function') {
     // Called as: scrypt(...,      callback, [encoding])
     //  shifting: scrypt(..., interruptStep,  callback, [encoding])
@@ -457,26 +525,9 @@ function scrypt(password, salt, logN, r, dkLen, interruptStep, callback, encodin
   }
 
   if (interruptStep <= 0) {
-    //
-    // Blocking async variant, calls callback.
-    //
-    smixStart();
-    smixStep1(0, N);
-    smixStep2(0, N);
-    smixFinish();
-    callback(getResult(encoding));
-
+    calculateSync();
   } else {
-    //
-    // Async variant with interruptions, calls callback.
-    //
-    smixStart();
-    interruptedFor(0, N, interruptStep*2, smixStep1, function() {
-      interruptedFor(0, N, interruptStep*2, smixStep2, function () {
-        smixFinish();
-        callback(getResult(encoding));
-      });
-    });
+    calculateAsync(0);
   }
 }