0.5.6

add sodium_malloc
crypto_box: fix keypair, implement seal/seal_open
2020-03-04 14:52:37 +01:00 · 2020-03-04 14:50:09 +01:00 · 2019-11-14 09:27:36 +01:00 · 2018-03-19 18:07:17 +00:00 · 2018-03-19 18:07:17 +00:00 · 2018-03-19 19:03:43 +01:00
3 changed files with 73 additions and 3 deletions
@@ -6,7 +6,7 @@ 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
+module.exports.crypto_kdf_KEYBYTES = 32

 function STORE64_LE(dest, int) {
  var mul = 1
@@ -29,7 +29,7 @@ module.exports.crypto_kdf_derive_from_key = function crypto_kdf_derive_from_key
  STORE64_LE(salt, subkey_id)

  var outlen = Math.min(subkey.length, module.exports.crypto_kdf_BYTES_MAX)
-  blake2b(outlen, key, salt, ctx_padded, true)
+  blake2b(outlen, key.subarray(0, module.exports.crypto_kdf_KEYBYTES), salt, ctx_padded, true)
    .final(subkey)
 }

@@ -1,5 +1,7 @@
 'use strict';

+var xsalsa20 = require('xsalsa20')
+
 // Based on https://github.com/dchest/tweetnacl-js/blob/6dcbcaf5f5cbfd313f2dcfe763db35c828c8ff5b/nacl-fast.js.

 var sodium = module.exports
@@ -1736,6 +1738,57 @@ function crypto_secretbox_open_easy(msg, box, n, k) {
  return true
 }

+function crypto_box_keypair(pk, sk) {
+  check(pk, crypto_box_PUBLICKEYBYTES)
+  check(sk, crypto_box_SECRETKEYBYTES)
+  randombytes(sk, 32)
+  return crypto_scalarmult_base(pk, sk)
+}
+
+function crypto_box_seal(c, m, pk) {
+  check(c, crypto_box_SEALBYTES + m.length)
+  check(pk, crypto_box_PUBLICKEYBYTES)
+
+  var epk = c.subarray(0, crypto_box_PUBLICKEYBYTES)
+  var esk = new Uint8Array(crypto_box_SECRETKEYBYTES)
+  crypto_box_keypair(epk, esk)
+
+  var n = new Uint8Array(crypto_box_NONCEBYTES)
+  sodium.crypto_generichash_batch(n, [ epk, pk ])
+
+  var s = new Uint8Array(crypto_box_PUBLICKEYBYTES)
+  crypto_scalarmult(s, esk, pk)
+
+  var k = new Uint8Array(crypto_box_BEFORENMBYTES)
+  var zero = new Uint8Array(16)
+  xsalsa20.core_hsalsa20(k, zero, s, xsalsa20.SIGMA)
+
+  crypto_secretbox_easy(c.subarray(epk.length), m, n, k)
+
+  cleanup(esk)
+}
+
+function crypto_box_seal_open(m, c, pk, sk) {
+  check(c, crypto_box_SEALBYTES)
+  check(m, c.length - crypto_box_SEALBYTES)
+  check(pk, crypto_box_PUBLICKEYBYTES)
+  check(sk, crypto_box_SECRETKEYBYTES)
+
+  var epk = c.subarray(0, crypto_box_PUBLICKEYBYTES)
+
+  var n = new Uint8Array(crypto_box_NONCEBYTES)
+  sodium.crypto_generichash_batch(n, [ epk, pk ])
+
+  var s = new Uint8Array(crypto_box_PUBLICKEYBYTES)
+  crypto_scalarmult(s, sk, epk)
+
+  var k = new Uint8Array(crypto_box_BEFORENMBYTES)
+  var zero = new Uint8Array(16)
+  xsalsa20.core_hsalsa20(k, zero, s, xsalsa20.SIGMA)
+
+  return crypto_secretbox_open_easy(m, c.subarray(epk.length), n, k)
+}
+
 var crypto_secretbox_KEYBYTES = 32,
    crypto_secretbox_NONCEBYTES = 24,
    crypto_secretbox_ZEROBYTES = 32,
@@ -1748,6 +1801,8 @@ var crypto_secretbox_KEYBYTES = 32,
    crypto_box_NONCEBYTES = crypto_secretbox_NONCEBYTES,
    crypto_box_ZEROBYTES = crypto_secretbox_ZEROBYTES,
    crypto_box_BOXZEROBYTES = crypto_secretbox_BOXZEROBYTES,
+    crypto_box_SEALBYTES = 48,
+    crypto_box_BEFORENMBYTES = 32,
    crypto_sign_BYTES = 64,
    crypto_sign_PUBLICKEYBYTES = 32,
    crypto_sign_SECRETKEYBYTES = 64,
@@ -1788,6 +1843,18 @@ sodium.crypto_secretbox_open_easy = crypto_secretbox_open_easy
 sodium.crypto_secretbox_detached = crypto_secretbox_detached
 sodium.crypto_secretbox_open_detached = crypto_secretbox_open_detached

+sodium.crypto_box_PUBLICKEYBYTES = crypto_box_PUBLICKEYBYTES
+sodium.crypto_box_SECRETKEYBYTES = crypto_box_SECRETKEYBYTES
+sodium.crypto_box_SEALBYTES = crypto_box_SEALBYTES
+sodium.crypto_box_BEFORENMBYTES = crypto_box_BEFORENMBYTES
+sodium.crypto_box_keypair = crypto_box_keypair
+sodium.crypto_box_seal = crypto_box_seal
+sodium.crypto_box_seal_open = crypto_box_seal_open
+
+sodium.sodium_malloc = function (n) {
+  return new Uint8Array(n)
+}
+
 function cleanup(arr) {
  for (var i = 0; i < arr.length; i++) arr[i] = 0;
 }
@@ -1,6 +1,6 @@
 {
  "name": "sodium-javascript",
-  "version": "0.5.4",
+  "version": "0.5.6",
  "description": "WIP - a pure javascript version of sodium-native",
  "main": "index.js",
  "dependencies": {
@@ -17,6 +17,9 @@
  "browser": {
    "crypto": false
  },
+  "react-native": {
+    "crypto": "crypto"
+  },
  "scripts": {
    "browser": "browserify test.js | browser-run",
    "browser-manual": "browserify test.js | browser-run -p 1234",
Author	SHA1	Message	Date
Mathias Buus	51f8fbc2d3	0.5.6	2020-03-04 14:52:37 +01:00
Mathias Buus	f790621e60	add sodium_malloc	2020-03-04 14:50:09 +01:00
Fedor Indutny	4e42b942a5	crypto_box: fix keypair, implement seal/seal_open Secret Key is a random nonce, and public key is a point on elliptic curve. `crypto_box_seal`/`crypto_box_seal_open` are implemented using existing primitives and newly exported `core_hsalsa20` in `xsalsa20`	2019-11-14 09:27:36 +01:00
Daniel Regeci	49587c3d7f	crypto_box_keypair - rename arguments to pk,sk	2018-03-19 18:07:17 +00:00
Daniel Regeci	92aee452df	crypto_box_keypair	2018-03-19 18:07:17 +00:00
Mathias Buus	e1ca83f1bd	0.5.5	2018-03-19 19:03:43 +01:00
Peter van Hardenberg	c81ef709d1	react-native doesn't want crypto set to an empty module (#14 ) React-Native is sort of like a browser, sort of a native environment. On react-native we don't have the browser's crypto implementation, so we need to require react-native-crypto. We can rewrite the module requirement to do that using the extraNodeModules feature in rn-cli.config.js, but the metro packager assumes that if there's a "browser" field in package.json that it's relevant to react-native libraries unless there's also a "react-native" field. Hurray. Anyway, this silly little patch tells metro not to replace crypto with an empty module but actually to use whatever you currently have crypto set to (which is not solved here, so you'll still have to do that.)	2018-03-19 18:58:24 +01:00
Jim Pick	4e1c69ba13	Change crypto_kdf_KEYBYTES to be 32 and use subarray instead of slice Thanks to Emil Bayes for the advice.	2018-03-03 17:24:12 +00:00
Jim Pick	5159d68fa9	In kdf, truncate key before passing to blake to match sodium-native behaviour Currently, sodium-native and sodium-javascript are returning different hashes. The code in hyperdrive passes a 64 byte secret key to the kdf, but only 32 bytes are used by the native version, but all 64 bytes are used in the javascript version. As a result, hyperdrive secret keys can't be imported/exported across the two sodium implementations. https://gist.github.com/jimpick/3e869522eddaad77ac1bc9e64f36e1a7	2018-03-03 17:24:12 +00:00