laag-libsodium 1.0.16.0

data/vendor/github.com/jedisct1/libsodium/test/default/sign.exp

@@ -0,0 +1,5 @@
+1024 tests
+ed25519ph sig: [10c5411e40bd10170fb890d4dfdb6d338c8cb11d2764a216ee54df10977dcdefd8ff755b1eeb3f16fce80e40e7aafc99083dbff43d5031baf04157b48423960d]
+ed25519ph tv sig: [98a70222f0b8121aa9d30f813d683f809e462b469c7ff87639499bb94e6dae4131f85042463c2a355a2003d062adf5aaa10b8c61e636062aaad11c2a26083406]
+pk: [b5076a8474a832daee4dd5b4040983b6623b5f344aca57d4d6ee4baf3f259e6e]
+sk: [421151a459faeade3d247115f94aedae42318124095afabe4d1451a559faedeeb5076a8474a832daee4dd5b4040983b6623b5f344aca57d4d6ee4baf3f259e6e]

data/vendor/github.com/jedisct1/libsodium/test/default/siphashx24.c

@@ -0,0 +1,33 @@
+
+#define TEST_NAME "siphashx24"
+#include "cmptest.h"
+
+#define MAXLEN 64
+
+int
+main(void)
+{
+    unsigned char in[MAXLEN];
+    unsigned char out[crypto_shorthash_siphashx24_BYTES];
+    unsigned char k[crypto_shorthash_siphashx24_KEYBYTES];
+    size_t        i;
+    size_t        j;
+
+    for (i = 0; i < crypto_shorthash_siphashx24_KEYBYTES; ++i) {
+        k[i] = (unsigned char) i;
+    }
+    for (i = 0; i < MAXLEN; ++i) {
+        in[i] = (unsigned char) i;
+        crypto_shorthash_siphashx24(out, in, (unsigned long long) i, k);
+        for (j = 0; j < crypto_shorthash_siphashx24_BYTES; ++j) {
+            printf("%02x", (unsigned int) out[j]);
+        }
+        printf("\n");
+    }
+    assert(crypto_shorthash_siphashx24_KEYBYTES >= crypto_shorthash_siphash24_KEYBYTES);
+    assert(crypto_shorthash_siphashx24_BYTES > crypto_shorthash_siphash24_BYTES);
+    assert(crypto_shorthash_siphashx24_bytes() == crypto_shorthash_siphashx24_BYTES);
+    assert(crypto_shorthash_siphashx24_keybytes() == crypto_shorthash_siphashx24_KEYBYTES);
+
+    return 0;
+}

data/vendor/github.com/jedisct1/libsodium/test/default/siphashx24.exp

@@ -0,0 +1,64 @@
+a3817f04ba25a8e66df67214c7550293
+da87c1d86b99af44347659119b22fc45
+8177228da4a45dc7fca38bdef60affe4
+9c70b60c5267a94e5f33b6b02985ed51
+f88164c12d9c8faf7d0f6e7c7bcd5579
+1368875980776f8854527a07690e9627
+14eeca338b208613485ea0308fd7a15e
+a1f1ebbed8dbc153c0b84aa61ff08239
+3b62a9ba6258f5610f83e264f31497b4
+264499060ad9baabc47f8b02bb6d71ed
+00110dc378146956c95447d3f3d0fbba
+0151c568386b6677a2b4dc6f81e5dc18
+d626b266905ef35882634df68532c125
+9869e247e9c08b10d029934fc4b952f7
+31fcefac66d7de9c7ec7485fe4494902
+5493e99933b0a8117e08ec0f97cfc3d9
+6ee2a4ca67b054bbfd3315bf85230577
+473d06e8738db89854c066c47ae47740
+a426e5e423bf4885294da481feaef723
+78017731cf65fab074d5208952512eb1
+9e25fc833f2290733e9344a5e83839eb
+568e495abe525a218a2214cd3e071d12
+4a29b54552d16b9a469c10528eff0aae
+c9d184ddd5a9f5e0cf8ce29a9abf691c
+2db479ae78bd50d8882a8a178a6132ad
+8ece5f042d5e447b5051b9eacb8d8f6f
+9c0b53b4b3c307e87eaee08678141f66
+abf248af69a6eae4bfd3eb2f129eeb94
+0664da1668574b88b935f3027358aef4
+aa4b9dc4bf337de90cd4fd3c467c6ab7
+ea5c7f471faf6bde2b1ad7d4686d2287
+2939b0183223fafc1723de4f52c43d35
+7c3956ca5eeafc3e363e9d556546eb68
+77c6077146f01c32b6b69d5f4ea9ffcf
+37a6986cb8847edf0925f0f1309b54de
+a705f0e69da9a8f907241a2e923c8cc8
+3dc47d1f29c448461e9e76ed904f6711
+0d62bf01e6fc0e1a0d3c4751c5d3692b
+8c03468bca7c669ee4fd5e084bbee7b5
+528a5bb93baf2c9c4473cce5d0d22bd9
+df6a301e95c95dad97ae0cc8c6913bd8
+801189902c857f39e73591285e70b6db
+e617346ac9c231bb3650ae34ccca0c5b
+27d93437efb721aa401821dcec5adf89
+89237d9ded9c5e78d8b1c9b166cc7342
+4a6d8091bf5e7d651189fa94a250b14c
+0e33f96055e7ae893ffc0e3dcf492902
+e61c432b720b19d18ec8d84bdc63151b
+f7e5aef549f782cf379055a608269b16
+438d030fd0b7a54fa837f2ad201a6403
+a590d3ee4fbf04e3247e0d27f286423f
+5fe2c1a172fe93c4b15cd37caef9f538
+2c97325cbd06b36eb2133dd08b3a017c
+92c814227a6bca949ff0659f002ad39e
+dce850110bd8328cfbd50841d6911d87
+67f14984c7da791248e32bb5922583da
+1938f2cf72d54ee97e94166fa91d2a36
+74481e9646ed49fe0f6224301604698e
+57fca5de98a9d6d8006438d0583d8a1d
+9fecde1cefdc1cbed4763674d9575359
+e3040c00eb28f15366ca73cbd872e740
+7697009a6a831dfecca91c5993670f7a
+5853542321f567a005d547a4f04759bd
+5150d1772f50834a503e069a973fbd7c

data/vendor/github.com/jedisct1/libsodium/test/default/sodium_core.c

@@ -0,0 +1,42 @@
+
+#define TEST_NAME "sodium_core"
+#include "cmptest.h"
+
+static void
+misuse_handler(void)
+{
+    printf("misuse_handler()\n");
+    exit(0);
+}
+
+int
+main(void)
+{
+    sodium_set_misuse_handler(NULL);
+    sodium_set_misuse_handler(misuse_handler);
+    sodium_set_misuse_handler(NULL);
+
+    assert(sodium_init() == 1);
+
+    (void) sodium_runtime_has_neon();
+    (void) sodium_runtime_has_sse2();
+    (void) sodium_runtime_has_sse3();
+    (void) sodium_runtime_has_ssse3();
+    (void) sodium_runtime_has_sse41();
+    (void) sodium_runtime_has_avx();
+    (void) sodium_runtime_has_avx2();
+    (void) sodium_runtime_has_avx512f();
+    (void) sodium_runtime_has_pclmul();
+    (void) sodium_runtime_has_aesni();
+    (void) sodium_runtime_has_rdrand();
+
+    sodium_set_misuse_handler(misuse_handler);
+#ifndef __EMSCRIPTEN__
+    sodium_misuse();
+    printf("Misuse handler returned\n");
+#else
+    printf("misuse_handler()\n");
+#endif
+
+    return 0;
+}

data/vendor/github.com/jedisct1/libsodium/test/default/sodium_core.exp

@@ -0,0 +1 @@
+misuse_handler()

data/vendor/github.com/jedisct1/libsodium/test/default/sodium_utils.c

@@ -0,0 +1,178 @@
+#define TEST_NAME "sodium_utils"
+#include "cmptest.h"
+
+int
+main(void)
+{
+    unsigned char  buf_add[1000];
+    unsigned char  buf1[1000];
+    unsigned char  buf2[1000];
+    unsigned char  buf1_rev[1000];
+    unsigned char  buf2_rev[1000];
+    unsigned char  nonce[24];
+    char           nonce_hex[49];
+    unsigned char *bin_padded;
+    size_t         bin_len, bin_len2;
+    size_t         bin_padded_len;
+    size_t         bin_padded_maxlen;
+    size_t         blocksize;
+    unsigned int   i;
+    unsigned int   j;
+
+    randombytes_buf(buf1, sizeof buf1);
+    memcpy(buf2, buf1, sizeof buf2);
+    printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
+    sodium_memzero(buf1, 0U);
+    printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
+    sodium_memzero(buf1, sizeof buf1 / 2);
+    printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
+    printf("%d\n", sodium_memcmp(buf1, buf2, 0U));
+    sodium_memzero(buf2, sizeof buf2 / 2);
+    printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
+
+    memset(nonce, 0, sizeof nonce);
+    sodium_increment(nonce, sizeof nonce);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    memset(nonce, 255, sizeof nonce);
+    sodium_increment(nonce, sizeof nonce);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    nonce[1] = 1U;
+    sodium_increment(nonce, sizeof nonce);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    nonce[1] = 0U;
+    sodium_increment(nonce, sizeof nonce);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    nonce[0] = 255U;
+    nonce[2] = 255U;
+    sodium_increment(nonce, sizeof nonce);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    for (i = 0U; i < 1000U; i++) {
+        bin_len = (size_t) randombytes_uniform(sizeof buf1);
+        randombytes_buf(buf1, bin_len);
+        randombytes_buf(buf2, bin_len);
+        for (j = 0U; j < bin_len; j++) {
+            buf1_rev[bin_len - 1 - j] = buf1[j];
+            buf2_rev[bin_len - 1 - j] = buf2[j];
+        }
+        if (memcmp(buf1_rev, buf2_rev, bin_len) *
+                sodium_compare(buf1, buf2, bin_len) <
+            0) {
+            printf("sodium_compare() failure with length=%u\n",
+                   (unsigned int) bin_len);
+        }
+        memcpy(buf1, buf2, bin_len);
+        if (sodium_compare(buf1, buf2, bin_len)) {
+            printf("sodium_compare() equality failure with length=%u\n",
+                   (unsigned int) bin_len);
+        }
+    }
+    memset(buf1, 0, sizeof buf1);
+    if (sodium_is_zero(buf1, sizeof buf1) != 1) {
+        printf("sodium_is_zero() failed\n");
+    }
+    for (i = 0U; i < sizeof buf1; i++) {
+        buf1[i]++;
+        if (sodium_is_zero(buf1, sizeof buf1) != 0) {
+            printf("sodium_is_zero() failed\n");
+        }
+        buf1[i]--;
+    }
+    bin_len = randombytes_uniform(sizeof buf1);
+    randombytes_buf(buf1, bin_len);
+    memcpy(buf2, buf1, bin_len);
+    memset(buf_add, 0, bin_len);
+    j = randombytes_uniform(10000);
+    for (i = 0U; i < j; i++) {
+        sodium_increment(buf1, bin_len);
+        sodium_increment(buf_add, bin_len);
+    }
+    sodium_add(buf2, buf_add, bin_len);
+    if (sodium_compare(buf1, buf2, bin_len) != 0) {
+        printf("sodium_add() failed\n");
+    }
+    bin_len = randombytes_uniform(sizeof buf1);
+    randombytes_buf(buf1, bin_len);
+    memcpy(buf2, buf1, bin_len);
+    memset(buf_add, 0xff, bin_len);
+    sodium_increment(buf2, bin_len);
+    sodium_increment(buf2, 0U);
+    sodium_add(buf2, buf_add, bin_len);
+    sodium_add(buf2, buf_add, 0U);
+    if (sodium_compare(buf1, buf2, bin_len) != 0) {
+        printf("sodium_add() failed\n");
+    }
+
+    assert(sizeof nonce >= 24U);
+    memset(nonce, 0xfe, 24U);
+    memset(nonce, 0xff, 6U);
+    sodium_increment(nonce, 8U);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    memset(nonce, 0xfe, 24U);
+    memset(nonce, 0xff, 10U);
+    sodium_increment(nonce, 12U);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    memset(nonce, 0xff, 22U);
+    sodium_increment(nonce, 24U);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+
+    assert(sizeof nonce >= 24U);
+    memset(nonce, 0xfe, 24U);
+    memset(nonce, 0xff, 6U);
+    sodium_add(nonce, nonce, 7U);
+    sodium_add(nonce, nonce, 8U);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    memset(nonce, 0xfe, 24U);
+    memset(nonce, 0xff, 10U);
+    sodium_add(nonce, nonce, 11U);
+    sodium_add(nonce, nonce, 12U);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+    memset(nonce, 0xff, 22U);
+    sodium_add(nonce, nonce, 23U);
+    sodium_add(nonce, nonce, 24U);
+    printf("%s\n",
+           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
+
+    for (i = 0; i < 2000U; i++) {
+        bin_len = randombytes_uniform(200U);
+        blocksize = 1U + randombytes_uniform(100U);
+        bin_padded_maxlen = bin_len + (blocksize - bin_len % blocksize);
+        bin_padded = (unsigned char *) sodium_malloc(bin_padded_maxlen);
+        randombytes_buf(bin_padded, bin_padded_maxlen);
+
+        assert(sodium_pad(&bin_padded_len, bin_padded, bin_len,
+                          blocksize, bin_padded_maxlen - 1U) == -1);
+        assert(sodium_pad(NULL, bin_padded, bin_len,
+                          blocksize, bin_padded_maxlen + 1U) == 0);
+        assert(sodium_pad(&bin_padded_len, bin_padded, bin_len,
+                          blocksize, bin_padded_maxlen + 1U) == 0);
+        assert(sodium_pad(&bin_padded_len, bin_padded, bin_len,
+                          0U, bin_padded_maxlen) == -1);
+        assert(sodium_pad(&bin_padded_len, bin_padded, bin_len,
+                          blocksize, bin_padded_maxlen) == 0);
+        assert(bin_padded_len == bin_padded_maxlen);
+
+        assert(sodium_unpad(&bin_len2, bin_padded, bin_padded_len,
+                            bin_padded_len + 1U) == -1);
+        assert(sodium_unpad(&bin_len2, bin_padded, bin_padded_len,
+                            0U) == -1);
+        assert(sodium_unpad(&bin_len2, bin_padded, bin_padded_len,
+                            blocksize) == 0);
+        assert(bin_len2 == bin_len);
+
+        sodium_free(bin_padded);
+    }
+
+    sodium_stackzero(512);
+
+    return 0;
+}

data/vendor/github.com/jedisct1/libsodium/test/default/sodium_utils.exp

@@ -0,0 +1,16 @@
+0
+0
+-1
+0
+0
+010000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000
+010100000000000000000000000000000000000000000000
+020000000000000000000000000000000000000000000000
+0001ff000000000000000000000000000000000000000000
+000000000000fffefefefefefefefefefefefefefefefefe
+00000000000000000000fffefefefefefefefefefefefefe
+00000000000000000000000000000000000000000000fffe
+fcfffffffffffbfdfefefefefefefefefefefefefefefefe
+fcfffffffffffffffffffbfdfefefefefefefefefefefefe
+fcfffffffffffffffffffffffffffffffffffffffffffbfd

data/vendor/github.com/jedisct1/libsodium/test/default/sodium_utils2.c

@@ -0,0 +1,98 @@
+
+#include <stdlib.h>
+#include <sys/types.h>
+
+#include <limits.h>
+#include <signal.h>
+
+#define TEST_NAME "sodium_utils2"
+#include "cmptest.h"
+
+#ifdef __SANITIZE_ADDRESS__
+# warning The sodium_utils2 test is expected to fail with address sanitizer
+#endif
+
+__attribute__((noreturn)) static void
+segv_handler(int sig)
+{
+    (void) sig;
+
+    printf("Intentional segfault / bus error caught\n");
+    printf("OK\n");
+#ifdef SIGSEGV
+    signal(SIGSEGV, SIG_DFL);
+#endif
+#ifdef SIGBUS
+    signal(SIGBUS, SIG_DFL);
+#endif
+#ifdef SIGABRT
+    signal(SIGABRT, SIG_DFL);
+#endif
+    exit(0);
+}
+
+int
+main(void)
+{
+    void *       buf;
+    size_t       size;
+    unsigned int i;
+
+    if (sodium_malloc(SIZE_MAX - 1U) != NULL) {
+        return 1;
+    }
+    if (sodium_malloc(0U) == NULL) {
+        return 1;
+    }
+    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);
+
+    sodium_free(sodium_malloc(0U));
+    sodium_free(NULL);
+    for (i = 0U; i < 10000U; i++) {
+        size = 1U + randombytes_uniform(100000U);
+        buf  = sodium_malloc(size);
+        assert(buf != NULL);
+        memset(buf, i, size);
+        sodium_mprotect_noaccess(buf);
+        sodium_free(buf);
+    }
+    printf("OK\n");
+
+#ifdef SIGSEGV
+    signal(SIGSEGV, segv_handler);
+#endif
+#ifdef SIGBUS
+    signal(SIGBUS, segv_handler);
+#endif
+#ifdef SIGABRT
+    signal(SIGABRT, segv_handler);
+#endif
+    size = 1U + randombytes_uniform(100000U);
+    buf  = sodium_malloc(size);
+    assert(buf != NULL);
+
+/* old versions of asan emit a warning because they don't support mlock*() */
+#ifndef __SANITIZE_ADDRESS__
+    sodium_mprotect_readonly(buf);
+    sodium_mprotect_readwrite(buf);
+#endif
+
+#if defined(HAVE_CATCHABLE_SEGV) && !defined(__EMSCRIPTEN__) && !defined(__SANITIZE_ADDRESS__)
+    sodium_memzero(((unsigned char *) buf) + size, 1U);
+    sodium_mprotect_noaccess(buf);
+    sodium_free(buf);
+    printf("Overflow not caught\n");
+#else
+    segv_handler(0);
+#endif
+    return 0;
+}

data/vendor/github.com/jedisct1/libsodium/test/default/sodium_utils2.exp

@@ -0,0 +1,3 @@
+OK
+Intentional segfault / bus error caught
+OK

data/vendor/github.com/jedisct1/libsodium/test/default/sodium_utils3.c

@@ -0,0 +1,68 @@
+
+#include <stdlib.h>
+#include <sys/types.h>
+
+#include <limits.h>
+#include <signal.h>
+
+#define TEST_NAME "sodium_utils3"
+#include "cmptest.h"
+
+#ifdef __SANITIZE_ADDRESS__
+# warning The sodium_utils3 test is expected to fail with address sanitizer
+#endif
+
+__attribute__((noreturn)) static void
+segv_handler(int sig)
+{
+    (void) sig;
+
+    printf("Intentional segfault / bus error caught\n");
+    printf("OK\n");
+#ifdef SIGSEGV
+    signal(SIGSEGV, SIG_DFL);
+#endif
+#ifdef SIGBUS
+    signal(SIGBUS, SIG_DFL);
+#endif
+#ifdef SIGABRT
+    signal(SIGABRT, SIG_DFL);
+#endif
+    exit(0);
+}
+
+int
+main(void)
+{
+    void * buf;
+    size_t size;
+
+#ifdef SIGSEGV
+    signal(SIGSEGV, segv_handler);
+#endif
+#ifdef SIGBUS
+    signal(SIGBUS, segv_handler);
+#endif
+#ifdef SIGABRT
+    signal(SIGABRT, segv_handler);
+#endif
+    size = 1U + randombytes_uniform(100000U);
+    buf  = sodium_malloc(size);
+    assert(buf != NULL);
+
+/* old versions of asan emit a warning because they don't support mlock*() */
+#ifndef __SANITIZE_ADDRESS__
+    sodium_mprotect_noaccess(buf);
+    sodium_mprotect_readwrite(buf);
+#endif
+
+#if defined(HAVE_CATCHABLE_SEGV) && !defined(__EMSCRIPTEN__) && !defined(__SANITIZE_ADDRESS__)
+    sodium_memzero(((unsigned char *) buf) - 8, 8U);
+    sodium_mprotect_readonly(buf);
+    sodium_free(buf);
+    printf("Underflow not caught\n");
+#else
+    segv_handler(0);
+#endif
+    return 0;
+}

data/vendor/github.com/jedisct1/libsodium/test/default/sodium_utils3.exp

@@ -0,0 +1,2 @@
+Intentional segfault / bus error caught
+OK

data/vendor/github.com/jedisct1/libsodium/test/default/sodium_version.c

@@ -0,0 +1,18 @@
+
+#define TEST_NAME "sodium_version"
+#include "cmptest.h"
+
+int
+main(void)
+{
+    printf("%d\n", sodium_version_string() != NULL);
+    printf("%d\n", sodium_library_version_major() > 0);
+    printf("%d\n", sodium_library_version_minor() >= 0);
+#ifdef SODIUM_LIBRARY_MINIMAL
+    assert(sodium_library_minimal() == 1);
+#else
+    assert(sodium_library_minimal() == 0);
+#endif
+
+    return 0;
+}

data/vendor/github.com/jedisct1/libsodium/test/default/sodium_version.exp

@@ -0,0 +1,3 @@
+1
+1
+1

data/vendor/github.com/jedisct1/libsodium/test/default/stream.c

@@ -0,0 +1,65 @@
+
+#define TEST_NAME "stream"
+#include "cmptest.h"
+
+static unsigned char firstkey[32] = { 0x1b, 0x27, 0x55, 0x64, 0x73, 0xe9, 0x85,
+                                      0xd4, 0x62, 0xcd, 0x51, 0x19, 0x7a, 0x9a,
+                                      0x46, 0xc7, 0x60, 0x09, 0x54, 0x9e, 0xac,
+                                      0x64, 0x74, 0xf2, 0x06, 0xc4, 0xee, 0x08,
+                                      0x44, 0xf6, 0x83, 0x89 };
+
+static unsigned char nonce[24] = { 0x69, 0x69, 0x6e, 0xe9, 0x55, 0xb6,
+                                   0x2b, 0x73, 0xcd, 0x62, 0xbd, 0xa8,
+                                   0x75, 0xfc, 0x73, 0xd6, 0x82, 0x19,
+                                   0xe0, 0x03, 0x6b, 0x7a, 0x0b, 0x37 };
+
+static unsigned char output[4194304];
+
+static unsigned char h[32];
+static char          hex[2 * 192 + 1];
+
+int
+main(void)
+{
+    int i;
+
+    randombytes_buf(output, sizeof output);
+    crypto_stream(output, sizeof output, nonce, firstkey);
+    crypto_hash_sha256(h, output, sizeof output);
+    sodium_bin2hex(hex, sizeof hex, h, sizeof h);
+    printf("%s\n", hex);
+
+    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);
+    sodium_bin2hex(hex, sizeof hex, h, sizeof h);
+    printf("%s\n", hex);
+
+    for (i = 0; i < 64; i++) {
+        memset(output, i, 64);
+        crypto_stream(output, (int) (i & 0xff), nonce, firstkey);
+        sodium_bin2hex(hex, sizeof hex, output, 64);
+        printf("%s\n", hex);
+    }
+
+    memset(output, 0, 192);
+    crypto_stream_xsalsa20_xor_ic(output, output, 192, nonce,
+                                  (1ULL << 32) - 1ULL, firstkey);
+    sodium_bin2hex(hex, 192 * 2 + 1, output, 192);
+    printf("%s\n", hex);
+
+    assert(crypto_stream_keybytes() > 0U);
+    assert(crypto_stream_noncebytes() > 0U);
+    assert(crypto_stream_messagebytes_max() > 0U);
+    assert(strcmp(crypto_stream_primitive(), "xsalsa20") == 0);
+    assert(crypto_stream_keybytes() == crypto_stream_xsalsa20_keybytes());
+    assert(crypto_stream_noncebytes() == crypto_stream_xsalsa20_noncebytes());
+    assert(crypto_stream_messagebytes_max() == crypto_stream_xsalsa20_messagebytes_max());
+
+    return 0;
+}

data/vendor/github.com/jedisct1/libsodium/test/default/stream.exp

@@ -0,0 +1,67 @@
+662b9d0e3463029156069b12f918691a98f7dfb2ca0393c96bbfc6b1fbd630a2
+0cc9ffaf60a99d221b548e9762385a231121ab226d1c610d2661ced26b6ad5ee
+00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+ee010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101
+eea60202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202
+eea6a703030303030303030303030303030303030303030303030303030303030303030303030303030303030303030303030303030303030303030303030303
+eea6a725040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404
+eea6a7251c0505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505
+eea6a7251c1e06060606060606060606060606060606060606060606060606060606060606060606060606060606060606060606060606060606060606060606
+eea6a7251c1e72070707070707070707070707070707070707070707070707070707070707070707070707070707070707070707070707070707070707070707
+eea6a7251c1e72910808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808
+eea6a7251c1e72916d09090909090909090909090909090909090909090909090909090909090909090909090909090909090909090909090909090909090909
+eea6a7251c1e72916d110a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a
+eea6a7251c1e72916d11c20b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b
+eea6a7251c1e72916d11c2cb0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c
+eea6a7251c1e72916d11c2cb210d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d
+eea6a7251c1e72916d11c2cb214d0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e
+eea6a7251c1e72916d11c2cb214d3c0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f
+eea6a7251c1e72916d11c2cb214d3c25101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010
+eea6a7251c1e72916d11c2cb214d3c25251111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
+eea6a7251c1e72916d11c2cb214d3c25253912121212121212121212121212121212121212121212121212121212121212121212121212121212121212121212
+eea6a7251c1e72916d11c2cb214d3c25253912131313131313131313131313131313131313131313131313131313131313131313131313131313131313131313
+eea6a7251c1e72916d11c2cb214d3c252539121d1414141414141414141414141414141414141414141414141414141414141414141414141414141414141414
+eea6a7251c1e72916d11c2cb214d3c252539121d8e15151515151515151515151515151515151515151515151515151515151515151515151515151515151515
+eea6a7251c1e72916d11c2cb214d3c252539121d8e23161616161616161616161616161616161616161616161616161616161616161616161616161616161616
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e1717171717171717171717171717171717171717171717171717171717171717171717171717171717
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e6518181818181818181818181818181818181818181818181818181818181818181818181818181818
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d191919191919191919191919191919191919191919191919191919191919191919191919191919
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651f1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa41c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c81d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cf1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff81f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff8802020202020202020202020202020202020202020202020202020202020202020
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff8803021212121212121212121212121212121212121212121212121212121212121
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e222222222222222222222222222222222222222222222222222222222222
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e642323232323232323232323232323232323232323232323232323232323
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a24242424242424242424242424242424242424242424242424242424
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74252525252525252525252525252525252525252525252525252525
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e92626262626262626262626262626262626262626262626262626
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e027272727272727272727272727272727272727272727272727
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a6282828282828282828282828282828282828282828282828
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d2929292929292929292929292929292929292929292929
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d822a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d82432b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243ac2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243acd92d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243acd9172e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243acd9177a2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f2f
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243acd9177ab530303030303030303030303030303030
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243acd9177ab51a313131313131313131313131313131
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243acd9177ab51a1b3232323232323232323232323232
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243acd9177ab51a1beb33333333333333333333333333
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243acd9177ab51a1beb8d343434343434343434343434
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243acd9177ab51a1beb8d5a3535353535353535353535
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243acd9177ab51a1beb8d5a2f36363636363636363636
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243acd9177ab51a1beb8d5a2f5d373737373737373737
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243acd9177ab51a1beb8d5a2f5d703838383838383838
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243acd9177ab51a1beb8d5a2f5d700c39393939393939
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243acd9177ab51a1beb8d5a2f5d700c093a3a3a3a3a3a
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243acd9177ab51a1beb8d5a2f5d700c093c3b3b3b3b3b
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243acd9177ab51a1beb8d5a2f5d700c093c5e3c3c3c3c
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243acd9177ab51a1beb8d5a2f5d700c093c5e553d3d3d
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243acd9177ab51a1beb8d5a2f5d700c093c5e55853e3e
+eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243acd9177ab51a1beb8d5a2f5d700c093c5e5585573f
+b46af0bf761b78533e01a0dd7e07216c9710ef35f09a28d1e5fa469b602472ca5085f6dbcc6a6b51fb89986f8feca85658d05701f5677d0bb340a1f2c769547219f5420c62ffff7d1304dad82b6dec2bdc59ec12a9e18a774eed128c2c90610a9d4c75c0817d64817a76bbc12746971ae897af210a072c1bc9fb044e086b7bfe85fad95d5c2bbb28c12de5755b1ccde63e93cc892b4d2bcbd7dc0706b094c2492e329e3b9a98a9cbc7d01031cf1d5861f576e1291df6286c28146b0b4df9ad44