0.4.0

* add browser test target
* add browser-manual target

crypto_generichash.js

@@ -1,4 +1,3 @@
-var assert = require('assert')
 var blake2b = require('blake2b')
 
 module.exports.crypto_generichash_PRIMITIVE = 'blake2b'
@@ -8,13 +7,17 @@ module.exports.crypto_generichash_BYTES = blake2b.BYTES
 module.exports.crypto_generichash_KEYBYTES_MIN = blake2b.KEYBYTES_MIN
 module.exports.crypto_generichash_KEYBYTES_MAX = blake2b.KEYBYTES_MAX
 module.exports.crypto_generichash_KEYBYTES = blake2b.KEYBYTES
+module.exports.crypto_generichash_WASM_SUPPORTED = blake2b.WASM_SUPPORTED
+module.exports.crypto_generichash_WASM_LOADED = false
 
 module.exports.crypto_generichash = function (output, input, key) {
-  blake2b(output, input, key)
+  blake2b(output.length, key).update(input).final(output)
 }
 
+module.exports.crypto_generichash_ready = blake2b.ready
+
 module.exports.crypto_generichash_batch = function (output, inputArray, key) {
-  var ctx = blake2b.instance(output.length, key)
+  var ctx = blake2b(output.length, key)
   for (var i = 0; i < inputArray.length; i++) {
     ctx.update(inputArray[i])
   }
@@ -23,5 +26,9 @@ module.exports.crypto_generichash_batch = function (output, inputArray, key) {
 
 module.exports.crypto_generichash_instance = function (key, outlen) {
   if (outlen == null) outlen = module.exports.crypto_generichash_BYTES
-  return blake2b.instance(outlen, key)
+  return blake2b(outlen, key)
 }
+
+blake2b.ready(function (err) {
+  module.exports.crypto_generichash_WASM_LOADED = blake2b.WASM_LOADED
+})

crypto_kdf.js

@@ -0,0 +1,39 @@
+var assert = require('nanoassert')
+var randombytes_buf = require('./randombytes').randombytes_buf
+var blake2b = require('blake2b')
+
+module.exports.crypto_kdf_PRIMITIVE = 'blake2b'
+module.exports.crypto_kdf_BYTES_MIN = 16
+module.exports.crypto_kdf_BYTES_MAX = 64
+module.exports.crypto_kdf_CONTEXTBYTES = 8
+module.exports.crypto_kdf_KEYBYTES = 64
+
+function STORE64_LE(dest, int) {
+  var mul = 1
+  var i = 0
+  dest[0] = int & 0xFF
+  while (++i < 8 && (mul *= 0x100)) {
+    dest[i] = (int / mul) & 0xFF
+  }
+}
+
+module.exports.crypto_kdf_derive_from_key = function crypto_kdf_derive_from_key (subkey, subkey_id, ctx, key) {
+  assert(subkey.length >= module.exports.crypto_kdf_BYTES_MIN, 'subkey must be at least crypto_kdf_BYTES_MIN')
+  assert(subkey_id >= 0 && subkey_id <= 0x1fffffffffffff, 'subkey_id must be safe integer')
+  assert(ctx.length >= module.exports.crypto_kdf_CONTEXTBYTES, 'context must be at least crypto_kdf_CONTEXTBYTES')
+
+  var ctx_padded = new Uint8Array(blake2b.PERSONALBYTES)
+  var salt = new Uint8Array(blake2b.SALTBYTES)
+
+  ctx_padded.set(ctx, 0, module.exports.crypto_kdf_CONTEXTBYTES)
+  STORE64_LE(salt, subkey_id)
+
+  var outlen = Math.min(subkey.length, module.exports.crypto_kdf_BYTES_MAX)
+  blake2b(outlen, key, salt, ctx_padded, true)
+    .final(subkey)
+}
+
+module.exports.crypto_kdf_keygen = function crypto_kdf_keygen (out) {
+  assert(out.length >= module.exports.crypto_kdf_KEYBYTES, 'out.length must be crypto_kdf_KEYBYTES')
+  randombytes_buf(out.subarray(0, module.exports.crypto_kdf_KEYBYTES))
+}

crypto_shorthash.js

@@ -0,0 +1,17 @@
+var siphash = require('siphash24')
+
+exports.crypto_shorthash_PRIMITIVE = 'siphash24'
+exports.crypto_shorthash_BYTES = siphash.BYTES
+exports.crypto_shorthash_KEYBYTES = siphash.KEYBYTES
+exports.crypto_shorthash_WASM_SUPPORTED = siphash.WASM_SUPPORTED
+exports.crypto_shorthash_WASM_LOADED = siphash.WASM_LOADED
+exports.crypto_shorthash_ready = siphash.ready
+exports.crypto_shorthash = shorthash
+
+siphash.ready(function () {
+  exports.crypto_shorthash_WASM_LOADED = siphash.WASM_LOADED
+})
+
+function shorthash (out, data, key, noAssert) {
+  siphash(data, key, out, noAssert)
+}

example.js

@@ -18,3 +18,5 @@ var plainText = new Buffer(cipher.length - sodium.crypto_secretbox_MACBYTES)
 sodium.crypto_secretbox_open_easy(plainText, cipher, nonce, key)
 
 console.log('Plaintext:', plainText.toString())
+
+if (typeof window !== 'undefined') window.close()

index.js

@@ -16,8 +16,8 @@ var gf = function(init) {
   return r;
 };
 
-//  Pluggable, initialized in high-level API below.
-var randombytes = function(/* x, n */) { throw new Error('no PRNG'); };
+// also forwarded at the bottom but randombytes is non-enumerable
+var randombytes = require('./randombytes').randombytes
 
 var _0 = new Uint8Array(16);
 var _9 = new Uint8Array(32); _9[0] = 9;
@@ -2112,10 +2112,6 @@ function crypto_sign_verify_detached (sig, m, pk) {
   return crypto_sign_open(sm, m, pk)
 }
 
-function randombytes_buf (n) {
-  randombytes(n, n.length)
-}
-
 function crypto_stream_wrap(c, n, k) {
   check(c, 0)
   check(n, sodium.crypto_stream_NONCEBYTES)
@@ -2184,8 +2180,6 @@ sodium.memzero = function (len, offset) {
   for (var i = offset; i < len; i++) arr[i] = 0;
 }
 
-sodium.randombytes_buf = randombytes_buf
-
 sodium.crypto_sign_BYTES = crypto_sign_BYTES
 sodium.crypto_sign_PUBLICKEYBYTES = crypto_sign_PUBLICKEYBYTES
 sodium.crypto_sign_SECRETKEYBYTES = crypto_sign_SECRETKEYBYTES
@@ -2198,6 +2192,9 @@ sodium.crypto_sign_detached = crypto_sign_detached
 sodium.crypto_sign_verify_detached = crypto_sign_verify_detached
 
 forward(require('./crypto_generichash'))
+forward(require('./crypto_kdf'))
+forward(require('./crypto_shorthash'))
+forward(require('./randombytes'))
 
 sodium.crypto_stream_KEYBYTES = 32
 sodium.crypto_stream_NONCEBYTES = 24
@@ -2228,31 +2225,3 @@ function forward (submodule) {
     module.exports[prop] = submodule[prop]
   })
 }
-
-(function() {
-  // Initialize PRNG if environment provides CSPRNG.
-  // If not, methods calling randombytes will throw.
-  var crypto = typeof self !== 'undefined' ? (self.crypto || self.msCrypto) : null;
-  if (crypto && crypto.getRandomValues) {
-    // Browsers.
-    var QUOTA = 65536;
-    randombytes = function(x, n) {
-      var i, v = new Uint8Array(n);
-      for (i = 0; i < n; i += QUOTA) {
-        crypto.getRandomValues(v.subarray(i, i + Math.min(n - i, QUOTA)));
-      }
-      for (i = 0; i < n; i++) x[i] = v[i];
-      cleanup(v);
-    };
-  } else if (typeof require !== 'undefined') {
-    // Node.js.
-    crypto = require('cry' + 'pto');
-    if (crypto && crypto.randomBytes) {
-      randombytes = function(x, n) {
-        var i, v = crypto.randomBytes(n);
-        for (i = 0; i < n; i++) x[i] = v[i];
-        cleanup(v);
-      };
-    }
-  }
-})();

package.json

@@ -1,13 +1,27 @@
 {
   "name": "sodium-javascript",
-  "version": "0.1.0",
+  "version": "0.4.0",
   "description": "WIP - a pure javascript version of sodium-native",
   "main": "index.js",
   "dependencies": {
-    "blake2b": "^1.2.0"
+    "blake2b": "^2.1.1",
+    "nanoassert": "^1.0.0",
+    "siphash24": "^1.0.1"
   },
   "devDependencies": {
-    "sodium-test": "^0.2.0"
+    "browser-run": "^4.0.2",
+    "browserify": "^14.1.0",
+    "sodium-test": "^0.5.1"
+  },
+  "scripts": {
+    "browser": "browserify example.js | browser-run",
+    "browser-manual": "browserify example.js | browser-run -p 1234",
+    "test": " node test.js"
+  },
+  "browserify": {
+    "transform": [
+      "brfs"
+    ]
   },
   "repository": {
     "type": "git",

randombytes.js

@@ -0,0 +1,40 @@
+var assert = require('nanoassert')
+var randombytes = (function () {
+  var QUOTA = 65536 // limit for QuotaExceededException
+  var crypto = typeof window !== 'undefined' ? (window.crypto || window.msCrypto) : null
+
+  function windowBytes (out, n) {
+    for (var i = 0; i < n; i += QUOTA) {
+      crypto.getRandomValues(out.subarray(i, i + Math.min(n - i, QUOTA)))
+    }
+  }
+
+  function nodeBytes (out, n) {
+    out.set(crypto.randomBytes(n))
+  }
+
+  function noImpl () {
+    throw new Error('No secure random number generator available')
+  }
+
+  if (crypto && crypto.getRandomValues) {
+    return windowBytes
+  } else if (typeof require !== 'undefined') {
+    // Node.js.
+    crypto = require('cry' + 'pto');
+    if (crypto && crypto.randomBytes) {
+      return nodeBytes
+    }
+  }
+
+  return noImpl
+})()
+
+Object.defineProperty(module.exports, 'randombytes', {
+  value: randombytes
+})
+
+module.exports.randombytes_buf = function (out) {
+  assert(out, 'out must be given')
+  randombytes(out, out.length)
+}