rbnacl-libsodium 1.0.2 → 1.0.3

data/vendor/libsodium/test/default/auth.c

@@ -17,6 +17,8 @@ int main(void)
     crypto_auth_hmacsha512_state st;
     int i;
 
+    assert(crypto_auth_hmacsha512_statebytes() ==
+           sizeof(crypto_auth_hmacsha512_state));
     crypto_auth(a, c, sizeof c - 1U, key);
     for (i = 0; i < sizeof a; ++i) {
         printf(",0x%02x", (unsigned int)a[i]);
@@ -55,6 +57,12 @@ int main(void)
     assert(crypto_auth_hmacsha512_keybytes() > 0U);
     assert(crypto_auth_hmacsha512256_bytes() == crypto_auth_bytes());
     assert(crypto_auth_hmacsha512256_keybytes() == crypto_auth_keybytes());
+    assert(crypto_auth_hmacsha512256_statebytes() >=
+           crypto_auth_hmacsha512256_keybytes());
+    assert(crypto_auth_hmacsha256_statebytes() ==
+           sizeof(crypto_auth_hmacsha256_state));
+    assert(crypto_auth_hmacsha512_statebytes() ==
+           sizeof(crypto_auth_hmacsha512_state));
 
     return 0;
 }

data/vendor/libsodium/test/default/auth5.c

@@ -1,6 +1,4 @@
 
-#include "windows/windows-quirks.h"
-
 #define TEST_NAME "auth5"
 #include "cmptest.h"
 

data/vendor/libsodium/test/default/auth7.c

@@ -1,6 +1,4 @@
 
-#include "windows/windows-quirks.h"
-
 #define TEST_NAME "auth7"
 #include "cmptest.h"
 

data/vendor/libsodium/test/default/box8.c

@@ -1,6 +1,4 @@
 
-#include "windows/windows-quirks.h"
-
 #define TEST_NAME "box8"
 #include "cmptest.h"
 

data/vendor/libsodium/test/default/box_easy2.c

@@ -31,7 +31,7 @@ int main(void)
     crypto_box_keypair(bobpk, bobsk);
     mlen = (size_t) randombytes_uniform((uint32_t)sizeof m);
     randombytes_buf(m, mlen);
-    randombytes_buf(nonce, sizeof nonce);
+    randombytes_buf(nonce, crypto_box_NONCEBYTES);
     crypto_box_easy(c, m, mlen, nonce, bobpk, alicesk);
     if (crypto_box_open_easy(m2, c,
                              (unsigned long long) mlen + crypto_box_MACBYTES,

data/vendor/libsodium/test/default/box_seal.c

@@ -0,0 +1,43 @@
+
+#define TEST_NAME "box_seal"
+#include "cmptest.h"
+
+int main(void)
+{
+    unsigned char pk[crypto_box_PUBLICKEYBYTES];
+    unsigned char sk[crypto_box_SECRETKEYBYTES];
+    unsigned char *c;
+    unsigned char *m;
+    unsigned char *m2;
+    size_t         m_len;
+    size_t         c_len;
+
+    crypto_box_keypair(pk, sk);
+    m_len = (size_t) randombytes_uniform(1000);
+    c_len = crypto_box_SEALBYTES + m_len;
+    m = (unsigned char *) sodium_malloc(m_len);
+    m2 = (unsigned char *) sodium_malloc(m_len);
+    c = (unsigned char *) sodium_malloc(c_len);
+    randombytes_buf(m, m_len);
+    if (crypto_box_seal(c, m, m_len, pk) != 0) {
+        printf("crypto_box_seal() failure\n");
+        return 1;
+    }
+    if (crypto_box_seal_open(m2, c, c_len, pk, sk) != 0) {
+        printf("crypto_box_seal_open() failure\n");
+        return 1;
+    }
+    printf("%d\n", memcmp(m, m2, m_len));
+
+    printf("%d\n", crypto_box_seal_open(m, c, 0U, pk, sk));
+    printf("%d\n", crypto_box_seal_open(m, c, c_len - 1U, pk, sk));
+    printf("%d\n", crypto_box_seal_open(m, c, c_len, sk, pk));
+
+    sodium_free(c);
+    sodium_free(m);
+    sodium_free(m2);
+
+    assert(crypto_box_sealbytes() == crypto_box_SEALBYTES);
+
+    return 0;
+}

data/vendor/libsodium/test/default/box_seal.exp

@@ -0,0 +1,4 @@
+0
+-1
+-1
+-1

data/vendor/libsodium/test/default/cmptest.h

@@ -9,6 +9,7 @@
 #include <string.h>
 
 #include "sodium.h"
+#include "quirks.h"
 
 #ifdef __EMSCRIPTEN__
 # undef TEST_SRCDIR

data/vendor/libsodium/test/default/generichash2.c

@@ -10,6 +10,7 @@ int main(void)
         k[crypto_generichash_KEYBYTES_MAX];
     size_t h, i, j;
 
+    assert(crypto_generichash_statebytes() == sizeof st);
     for (h = 0; h < crypto_generichash_KEYBYTES_MAX; ++h)
         k[h] = h;
 

data/vendor/libsodium/test/default/hash.c

@@ -36,6 +36,8 @@ int main(void)
     assert(crypto_hash_sha256_bytes() > 0U);
     assert(crypto_hash_sha512_bytes() >= crypto_hash_sha256_bytes());
     assert(crypto_hash_sha512_bytes() == crypto_hash_bytes());
+    assert(crypto_hash_sha256_statebytes() == sizeof(crypto_hash_sha256_state));
+    assert(crypto_hash_sha512_statebytes() == sizeof(crypto_hash_sha512_state));
 
     return 0;
 }

data/vendor/libsodium/test/default/onetimeauth.c

@@ -27,6 +27,7 @@ int main(void)
     crypto_onetimeauth_state st;
     int i;
 
+    assert(crypto_onetimeauth_statebytes() == sizeof st);
     crypto_onetimeauth(a, c, 131, rs);
     for (i = 0; i < 16; ++i) {
         printf(",0x%02x", (unsigned int)a[i]);

data/vendor/libsodium/test/default/onetimeauth7.c

@@ -1,6 +1,4 @@
 
-#include "windows/windows-quirks.h"
-
 #define TEST_NAME "onetimeauth7"
 #include "cmptest.h"
 

data/vendor/libsodium/test/default/pre.js.inc

@@ -6,34 +6,7 @@ try {
 }
 Module['preRun'] = Module['preRun'] || [];
 Module['preRun'].push(function(){
-    var randombyte = null;
-    try {
-        function randombyte_standard() {
-            var buf = new Int8Array(1);            
-            window.crypto.getRandomValues(buf);
-            return buf[0];
-        }
-        randombyte_standard();
-        randombyte = randombyte_standard;
-    } catch (e) {
-        try {
-            var crypto = require('crypto');
-            function randombyte_node() {
-                return crypto.randomBytes(1)[0];
-            }
-            randombyte_node();
-            randombyte = randombyte_node;
-        } catch(e) {
-            throw 'No secure random number generator found';
-        }
-    }
     FS.init();
     FS.mkdir('/test-data');
     FS.mount(NODEFS,  { root: '.' }, '/test-data');
-    FS.analyzePath('/dev/random').exists && FS.unlink('/dev/random');
-    FS.analyzePath('/dev/urandom') && FS.unlink('/dev/urandom');
-    var devFolder = FS.findObject('/dev') ||
-        Module['FS_createFolder']('/', 'dev', true, true);
-    Module['FS_createDevice'](devFolder, 'random', randombyte);
-    Module['FS_createDevice'](devFolder, 'urandom', randombyte);
 });

data/vendor/libsodium/test/default/pwhash.c

@@ -276,8 +276,8 @@ static void tv3(void)
         passwd = (char *) sodium_malloc(strlen(tests[i].passwd) + 1U);
         assert(passwd != NULL);
         memcpy(passwd, tests[i].passwd, strlen(tests[i].passwd) + 1U);
-        if (crypto_pwhash_scryptsalsa208sha256_str_verify(
-                out, passwd, strlen(passwd)) != 0) {
+        if (crypto_pwhash_scryptsalsa208sha256_str_verify
+            (out, passwd, strlen(passwd)) != 0) {
             printf("pwhash_str failure: [%u]\n", (unsigned int)i);
         }
         sodium_free(out);
@@ -287,14 +287,22 @@ static void tv3(void)
 
 int main(void)
 {
-    char        str_out[crypto_pwhash_scryptsalsa208sha256_STRBYTES];
-    char        str_out2[crypto_pwhash_scryptsalsa208sha256_STRBYTES];
-    const char *salt = "[<~A 32-bytes salt for scrypt~>]";
+    char       *str_out;
+    char       *str_out2;
+    char       *salt;
     const char *passwd = "Correct Horse Battery Staple";
 
     tv();
     tv2();
     tv3();
+    salt = (char *)
+        sodium_malloc(crypto_pwhash_scryptsalsa208sha256_SALTBYTES);
+    str_out = (char *)
+        sodium_malloc(crypto_pwhash_scryptsalsa208sha256_STRBYTES);
+    str_out2 = (char *)
+        sodium_malloc(crypto_pwhash_scryptsalsa208sha256_STRBYTES);
+    memcpy(salt, "[<~A 32-bytes salt for scrypt~>]",
+           crypto_pwhash_scryptsalsa208sha256_SALTBYTES);
     if (crypto_pwhash_scryptsalsa208sha256_str(str_out, passwd, strlen(passwd),
                                                OPSLIMIT, MEMLIMIT) != 0) {
         printf("pwhash_str failure\n");
@@ -321,6 +329,7 @@ int main(void)
     }
     str_out[14]--;
 
+    assert(str_out[crypto_pwhash_scryptsalsa208sha256_STRBYTES - 1U] == 0);
     assert(crypto_pwhash_scryptsalsa208sha256_saltbytes() > 0U);
     assert(crypto_pwhash_scryptsalsa208sha256_strbytes() > 1U);
     assert(crypto_pwhash_scryptsalsa208sha256_strbytes() >
@@ -330,6 +339,10 @@ int main(void)
     assert(crypto_pwhash_scryptsalsa208sha256_opslimit_sensitive() > 0U);
     assert(crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive() > 0U);
 
+    sodium_free(salt);
+    sodium_free(str_out);
+    sodium_free(str_out2);
+
     printf("OK\n");
 
     return 0;

data/vendor/libsodium/test/default/randombytes.c

@@ -27,11 +27,24 @@ static int compat_tests(void)
 
 static int randombytes_tests(void)
 {
+    unsigned int f = 0U;
     unsigned int i;
+    uint32_t     n;
 
-    assert(strcmp(randombytes_implementation_name(), "sysrandom") == 0);
-
+#ifdef __EMSCRIPTEN__
+    assert(strcmp(randombytes_implementation_name(), "sysrandom"));
+#else
+    assert(strcmp(randombytes_implementation_name(), "js"));
+#endif
     randombytes(x, 1U);
+    do {
+        n = randombytes_random();
+        f |= ((n >> 24) > 1);
+        f |= ((n >> 16) > 1) << 1;
+        f |= ((n >>  8) > 1) << 2;
+        f |= ((n      ) > 1) << 3;
+        f |= (n > 0x7fffffff) << 4;
+    } while (f != 0x1f);
     randombytes_close();
 
     for (i = 0; i < 256; ++i) {
@@ -47,8 +60,10 @@ static int randombytes_tests(void)
     }
     assert(randombytes_uniform(1U) == 0U);
     randombytes_close();
+#ifndef __EMSCRIPTEN__
     randombytes_set_implementation(&randombytes_salsa20_implementation);
     assert(strcmp(randombytes_implementation_name(), "salsa20") == 0);
+#endif
     randombytes_stir();
     for (i = 0; i < 256; ++i) {
         freq[i] = 0;
@@ -83,10 +98,37 @@ static int randombytes_tests(void)
     return 0;
 }
 
+static uint32_t randombytes_uniform_impl(const uint32_t upper_bound)
+{
+    return upper_bound;
+}
+
+static int impl_tests(void)
+{
+    randombytes_implementation impl = randombytes_sysrandom_implementation;
+    uint32_t                   v = randombytes_random();
+
+    impl.uniform = randombytes_uniform_impl;
+    randombytes_close();
+    randombytes_set_implementation(&impl);
+    assert(randombytes_uniform(v) == v);
+    assert(randombytes_uniform(v) == v);
+    assert(randombytes_uniform(v) == v);
+    assert(randombytes_uniform(v) == v);
+    randombytes_close();
+    impl.close = NULL;
+    randombytes_close();
+
+    return 0;
+}
+
 int main(void)
 {
     compat_tests();
     randombytes_tests();
+#ifndef __EMSCRIPTEN__
+    impl_tests();
+#endif
     printf("OK\n");
 
     return 0;

data/vendor/libsodium/test/default/secretbox8.c

@@ -1,6 +1,4 @@
 
-#include "windows/windows-quirks.h"
-
 #define TEST_NAME "secretbox8"
 #include "cmptest.h"
 

data/vendor/libsodium/test/default/sodium_utils2.c

@@ -8,7 +8,7 @@
 #include "cmptest.h"
 
 #ifdef __SANITIZE_ADDRESS__
-# error This test requires address sanitizer to be off
+# warning The sodium_utils2 test is expected to fail with address sanitizer
 #endif
 
 static void segv_handler(int sig)
@@ -39,6 +39,10 @@ int main(void)
     if (sodium_allocarray(SIZE_MAX / 2U + 1U, SIZE_MAX / 2U) != NULL) {
         return 1;
     }
+    sodium_free(sodium_allocarray(0U, 0U));
+    sodium_free(sodium_allocarray(0U, 1U));
+    sodium_free(sodium_allocarray(1U, 0U));
+
     buf = sodium_allocarray(1000U, 50U);
     memset(buf, 0, 50000U);
     sodium_free(buf);

data/vendor/libsodium/test/default/sodium_utils3.c

@@ -8,7 +8,7 @@
 #include "cmptest.h"
 
 #ifdef __SANITIZE_ADDRESS__
-# error This test requires address sanitizer to be off
+# warning The sodium_utils3 test is expected to fail with address sanitizer
 #endif
 
 static void segv_handler(int sig)

data/vendor/libsodium/test/default/stream.c

@@ -19,13 +19,25 @@ int main(void)
 {
     int i;
 
-    crypto_stream(output, 4194304, nonce, firstkey);
+    crypto_stream(output, sizeof output, nonce, firstkey);
     crypto_hash_sha256(h, output, sizeof output);
 
     for (i = 0; i < 32; ++i)
         printf("%02x", h[i]);
     printf("\n");
 
+    assert(sizeof output > 4000);
+
+    crypto_stream_xsalsa20_xor_ic(output, output, 4000, nonce, 0U, firstkey);
+    for (i = 0; i < 4000; ++i)
+        assert(output[i] == 0);
+
+    crypto_stream_xsalsa20_xor_ic(output, output, 4000, nonce, 1U, firstkey);
+    crypto_hash_sha256(h, output, sizeof output);
+    for (i = 0; i < 32; ++i)
+        printf("%02x", h[i]);
+    printf("\n");
+
     assert(crypto_stream_keybytes() > 0U);
     assert(crypto_stream_noncebytes() > 0U);
     assert(strcmp(crypto_stream_primitive(), "xsalsa20") == 0);

data/vendor/libsodium/test/default/stream.exp

@@ -1 +1,2 @@
 662b9d0e3463029156069b12f918691a98f7dfb2ca0393c96bbfc6b1fbd630a2
+0cc9ffaf60a99d221b548e9762385a231121ab226d1c610d2661ced26b6ad5ee

data/vendor/libsodium/test/default/stream2.c

@@ -17,7 +17,19 @@ unsigned char h[32];
 int main(void)
 {
     int i;
-    crypto_stream_salsa20(output, 4194304, noncesuffix, secondkey);
+    crypto_stream_salsa20(output, sizeof output, noncesuffix, secondkey);
+    crypto_hash_sha256(h, output, sizeof output);
+    for (i = 0; i < 32; ++i)
+        printf("%02x", h[i]);
+    printf("\n");
+
+    assert(sizeof output > 4000);
+
+    crypto_stream_salsa20_xor_ic(output, output, 4000, noncesuffix, 0U, secondkey);
+    for (i = 0; i < 4000; ++i)
+        assert(output[i] == 0);
+
+    crypto_stream_salsa20_xor_ic(output, output, 4000, noncesuffix, 1U, secondkey);
     crypto_hash_sha256(h, output, sizeof output);
     for (i = 0; i < 32; ++i)
         printf("%02x", h[i]);

data/vendor/libsodium/test/default/stream2.exp

@@ -1 +1,2 @@
 662b9d0e3463029156069b12f918691a98f7dfb2ca0393c96bbfc6b1fbd630a2
+0cc9ffaf60a99d221b548e9762385a231121ab226d1c610d2661ced26b6ad5ee

data/vendor/libsodium/test/quirks/quirks.h

@@ -0,0 +1,26 @@
+
+#include <stdlib.h>
+
+#ifdef __EMSCRIPTEN__
+# define strcmp(s1, s2) xstrcmp(s1, s2)
+
+int
+strcmp(const char *s1, const char *s2) {
+    while (*s1 == *s2++) { if (*s1++ == 0) return 0; }
+    return *(unsigned char *) s1 - *(unsigned char *) --s2;
+}
+#endif
+
+#ifdef _WIN32
+static void
+srandom(unsigned seed)
+{
+    srand(seed);
+}
+
+static long
+random(void)
+{
+    return (long) rand();
+}
+#endif