laag-libsodium 1.0.16.0

data/vendor/github.com/jedisct1/libsodium/test/default/cmptest.h

@@ -0,0 +1,138 @@
+
+#ifndef __CMPTEST_H__
+#define __CMPTEST_H__
+
+#ifdef NDEBUG
+#/**/undef/**/ NDEBUG
+#endif
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include "sodium.h"
+#include "quirks.h"
+
+#ifdef __EMSCRIPTEN__
+# undef TEST_SRCDIR
+# define TEST_SRCDIR "/test-data"
+#endif
+#ifndef TEST_SRCDIR
+# define TEST_SRCDIR "."
+#endif
+
+#define TEST_NAME_RES TEST_NAME ".res"
+#define TEST_NAME_OUT TEST_SRCDIR "/" TEST_NAME ".exp"
+
+#ifdef HAVE_ARC4RANDOM
+# undef rand
+# define rand(X) arc4random(X)
+#endif
+
+int xmain(void);
+
+#ifdef BENCHMARKS
+
+# include <sys/time.h>
+
+# ifndef ITERATIONS
+#  define ITERATIONS 128
+# endif
+
+static unsigned long long now(void)
+{
+    struct             timeval tp;
+    unsigned long long now;
+
+    if (gettimeofday(&tp, NULL) != 0) {
+        abort();
+    }
+    now = ((unsigned long long) tp.tv_sec * 1000000ULL) +
+        (unsigned long long) tp.tv_usec;
+
+    return now;
+}
+
+int main(void)
+{
+    unsigned long long ts_start;
+    unsigned long long ts_end;
+    unsigned int       i;
+
+    if (sodium_init() != 0) {
+        return 99;
+    }
+    randombytes_set_implementation(&randombytes_salsa20_implementation);
+    ts_start = now();
+    for (i = 0; i < ITERATIONS; i++) {
+        if (xmain() != 0) {
+            abort();
+        }
+    }
+    ts_end = now();
+    printf("%llu\n", 1000000ULL * (ts_end - ts_start) / ITERATIONS);
+
+    return 0;
+}
+
+#define printf(...) do { } while(0)
+
+#elif !defined(BROWSER_TESTS)
+
+FILE *fp_res;
+
+int main(void)
+{
+    FILE *fp_out;
+    int   c;
+
+    if ((fp_res = fopen(TEST_NAME_RES, "w+")) == NULL) {
+        perror("fopen(" TEST_NAME_RES ")");
+        return 99;
+    }
+    if (sodium_init() != 0) {
+        return 99;
+    }
+    if (xmain() != 0) {
+        return 99;
+    }
+    rewind(fp_res);
+    if ((fp_out = fopen(TEST_NAME_OUT, "r")) == NULL) {
+        perror("fopen(" TEST_NAME_OUT ")");
+        return 99;
+    }
+    do {
+        if ((c = fgetc(fp_res)) != fgetc(fp_out)) {
+            return 99;
+        }
+    } while (c != EOF);
+
+    return 0;
+}
+
+#undef  printf
+#define printf(...) fprintf(fp_res, __VA_ARGS__)
+
+#else
+
+int main(void)
+{
+    if (sodium_init() != 0) {
+        return 99;
+    }
+    if (xmain() != 0) {
+        return 99;
+    }
+    printf("--- SUCCESS ---\n");
+
+    return 0;
+}
+
+#endif
+
+#define main xmain
+
+#endif

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

@@ -0,0 +1,226 @@
+#define TEST_NAME "codecs"
+#include "cmptest.h"
+
+int
+main(void)
+{
+    unsigned char  buf1[1000];
+    char           buf3[33];
+    unsigned char  buf4[4];
+    const char    *b64;
+    char          *b64_;
+    const char    *b64_end;
+    unsigned char *bin;
+    unsigned char *bin_padded;
+    const char    *hex;
+    const char    *hex_end;
+    size_t         b64_len;
+    size_t         bin_len, bin_len2;
+    unsigned int   i;
+
+    printf("%s\n",
+           sodium_bin2hex(buf3, 33U, (const unsigned char *) "0123456789ABCDEF",
+                          16U));
+    hex = "Cafe : 6942";
+    sodium_hex2bin(buf4, sizeof buf4, hex, strlen(hex), ": ", &bin_len,
+                   &hex_end);
+    printf("%lu:%02x%02x%02x%02x\n", (unsigned long) bin_len,
+           buf4[0], buf4[1], buf4[2], buf4[3]);
+    printf("dt1: %ld\n", (long) (hex_end - hex));
+
+    hex = "Cafe : 6942";
+    sodium_hex2bin(buf4, sizeof buf4, hex, strlen(hex), ": ", &bin_len, NULL);
+    printf("%lu:%02x%02x%02x%02x\n", (unsigned long) bin_len,
+           buf4[0], buf4[1], buf4[2], buf4[3]);
+
+    hex = "deadbeef";
+    if (sodium_hex2bin(buf1, 1U, hex, 8U, NULL, &bin_len, &hex_end) != -1) {
+        printf("sodium_hex2bin() overflow not detected\n");
+    }
+    printf("dt2: %ld\n", (long) (hex_end - hex));
+
+    hex = "de:ad:be:eff";
+    if (sodium_hex2bin(buf1, 4U, hex, 12U, ":", &bin_len, &hex_end) != -1) {
+        printf(
+            "sodium_hex2bin() with an odd input length and a short output "
+            "buffer\n");
+    }
+    printf("dt3: %ld\n", (long) (hex_end - hex));
+
+    hex = "de:ad:be:eff";
+    if (sodium_hex2bin(buf1, sizeof buf1, hex, 12U, ":",
+                       &bin_len, &hex_end) != -1) {
+        printf("sodium_hex2bin() with an odd input length\n");
+    }
+    printf("dt4: %ld\n", (long) (hex_end - hex));
+
+    hex = "de:ad:be:eff";
+    if (sodium_hex2bin(buf1, sizeof buf1, hex, 13U, ":",
+                       &bin_len, &hex_end) != -1) {
+        printf("sodium_hex2bin() with an odd input length (2)\n");
+    }
+    printf("dt5: %ld\n", (long) (hex_end - hex));
+
+    hex = "de:ad:be:eff";
+    if (sodium_hex2bin(buf1, sizeof buf1, hex, 12U, ":",
+                       &bin_len, NULL) != -1) {
+        printf("sodium_hex2bin() with an odd input length and no end pointer\n");
+    }
+
+    hex = "de:ad:be:ef*";
+    if (sodium_hex2bin(buf1, sizeof buf1, hex, 12U, ":",
+                       &bin_len, &hex_end) != 0) {
+        printf("sodium_hex2bin() with an extra character and an end pointer\n");
+    }
+    printf("dt6: %ld\n", (long) (hex_end - hex));
+
+    hex = "de:ad:be:ef*";
+    if (sodium_hex2bin(buf1, sizeof buf1, hex, 12U, ":",
+                       &bin_len, NULL) != -1) {
+        printf("sodium_hex2bin() with an extra character and no end pointer\n");
+    }
+
+    printf("%s\n",
+           sodium_bin2base64(buf3, 31U, (const unsigned char *) "\xfb\xf0\xf1" "0123456789ABCDEFab",
+                             21U, sodium_base64_VARIANT_ORIGINAL));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 33U, (const unsigned char *) "\xfb\xf0\xf1" "0123456789ABCDEFabc",
+                             22U, sodium_base64_VARIANT_ORIGINAL_NO_PADDING));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 31U, (const unsigned char *) "\xfb\xf0\xf1" "0123456789ABCDEFab",
+                             21U, sodium_base64_VARIANT_URLSAFE));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 33U, (const unsigned char *) "\xfb\xf0\xf1" "0123456789ABCDEFabc",
+                             22U, sodium_base64_VARIANT_URLSAFE_NO_PADDING));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 1U, NULL,
+                             0U, sodium_base64_VARIANT_ORIGINAL));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 5U, (const unsigned char *) "a",
+                             1U, sodium_base64_VARIANT_ORIGINAL));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 5U, (const unsigned char *) "ab",
+                             2U, sodium_base64_VARIANT_ORIGINAL));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 5U, (const unsigned char *) "abc",
+                             3U, sodium_base64_VARIANT_ORIGINAL));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 1U, NULL,
+                             0U, sodium_base64_VARIANT_ORIGINAL_NO_PADDING));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 3U, (const unsigned char *) "a",
+                             1U, sodium_base64_VARIANT_ORIGINAL_NO_PADDING));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 4U, (const unsigned char *) "ab",
+                             2U, sodium_base64_VARIANT_ORIGINAL_NO_PADDING));
+    printf("%s\n",
+           sodium_bin2base64(buf3, 5U, (const unsigned char *) "abc",
+                             3U, sodium_base64_VARIANT_ORIGINAL_NO_PADDING));
+
+    b64 = "VGhpcyBpcyBhIGpvdXJu" "\n" "ZXkgaW50by" " " "Bzb3VuZA==";
+    memset(buf4, '*', sizeof buf4);
+    assert(sodium_base642bin(buf4, sizeof buf4, b64, strlen(b64), "\n\r ", &bin_len,
+                             &b64_end, sodium_base64_VARIANT_ORIGINAL) == -1);
+    buf4[bin_len] = 0;
+    printf("[%s]\n", (const char *) buf4);
+    printf("[%s]\n", b64_end);
+
+    memset(buf1, '*', sizeof buf1);
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), "\n\r ", &bin_len,
+                             &b64_end, sodium_base64_VARIANT_ORIGINAL) == 0);
+    buf1[bin_len] = 0;
+    printf("[%s]\n", (const char *) buf1);
+    assert(*b64_end == 0);
+
+    memset(buf1, '*', sizeof buf1);
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), NULL, &bin_len,
+                             &b64_end, sodium_base64_VARIANT_ORIGINAL) == 0);
+    buf1[bin_len] = 0;
+    printf("[%s]\n", (const char *) buf1);
+    printf("[%s]\n", b64_end);
+
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), NULL, NULL,
+                             &b64_end, sodium_base64_VARIANT_ORIGINAL) == 0);
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), NULL, NULL,
+                             &b64_end, sodium_base64_VARIANT_ORIGINAL_NO_PADDING) == 0);
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), " \r\n", NULL,
+                             &b64_end, sodium_base64_VARIANT_ORIGINAL_NO_PADDING) == 0);
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), NULL, NULL,
+                             &b64_end, sodium_base64_VARIANT_URLSAFE_NO_PADDING) == 0);
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), " \r\n", NULL,
+                             &b64_end, sodium_base64_VARIANT_URLSAFE_NO_PADDING) == 0);
+
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), NULL, NULL,
+                             NULL, sodium_base64_VARIANT_ORIGINAL) == -1);
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), NULL, NULL,
+                             NULL, sodium_base64_VARIANT_ORIGINAL_NO_PADDING) == -1);
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), " \r\n", NULL,
+                             NULL, sodium_base64_VARIANT_ORIGINAL_NO_PADDING) == -1);
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), NULL, NULL,
+                             NULL, sodium_base64_VARIANT_URLSAFE_NO_PADDING) == -1);
+    assert(sodium_base642bin(buf1, sizeof buf1, b64, strlen(b64), " \r\n", NULL,
+                             NULL, sodium_base64_VARIANT_URLSAFE_NO_PADDING) == -1);
+
+    assert(sodium_base642bin(NULL, (size_t) 10U, "a=", (size_t) 2U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_URLSAFE) == -1);
+    assert(sodium_base642bin(NULL, (size_t) 10U, "a*", (size_t) 2U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_URLSAFE) == -1);
+    assert(sodium_base642bin(NULL, (size_t) 10U, "a*", (size_t) 2U, "~", NULL, NULL,
+                             sodium_base64_VARIANT_URLSAFE) == -1);
+    assert(sodium_base642bin(NULL, (size_t) 10U, "a*", (size_t) 2U, "*", NULL, NULL,
+                             sodium_base64_VARIANT_URLSAFE) == -1);
+    assert(sodium_base642bin(NULL, (size_t) 10U, "a==", (size_t) 3U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_URLSAFE) == -1);
+    assert(sodium_base642bin(NULL, (size_t) 10U, "a=*", (size_t) 3U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_URLSAFE) == -1);
+    assert(sodium_base642bin(NULL, (size_t) 10U, "a=*", (size_t) 3U, "~", NULL, NULL,
+                             sodium_base64_VARIANT_URLSAFE) == -1);
+    assert(sodium_base642bin(NULL, (size_t) 10U, "a=*", (size_t) 3U, "*", NULL, NULL,
+                             sodium_base64_VARIANT_URLSAFE) == -1);
+
+    assert(sodium_base642bin(buf1, sizeof buf1, "O1R", (size_t) 3U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL_NO_PADDING) == -1);
+    assert(sodium_base642bin(buf1, sizeof buf1, "O1Q", (size_t) 3U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL_NO_PADDING) == 0);
+    assert(sodium_base642bin(buf1, sizeof buf1, "O1", (size_t) 2U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL_NO_PADDING) == -1);
+    assert(sodium_base642bin(buf1, sizeof buf1, "Ow", (size_t) 2U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL_NO_PADDING) == 0);
+    assert(sodium_base642bin(buf1, sizeof buf1, "O", (size_t) 1U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL_NO_PADDING) == -1);
+
+    assert(sodium_base642bin(buf1, sizeof buf1, "kaw", (size_t) 3U, NULL, NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL) == -1);
+    assert(sodium_base642bin(buf1, sizeof buf1, "kQ*", (size_t) 3U, "@", NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL) == -1);
+    assert(sodium_base642bin(buf1, sizeof buf1, "kQ*", (size_t) 3U, "*", NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL) == -1);
+    assert(sodium_base642bin(buf1, sizeof buf1, "kaw=**", (size_t) 6U, "*", NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL) == 0);
+    assert(sodium_base642bin(buf1, sizeof buf1, "kaw*=*", (size_t) 6U, "~*", NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL) == 0);
+    assert(sodium_base642bin(buf1, sizeof buf1, "ka*w*=*", (size_t) 7U, "*~", NULL, NULL,
+                             sodium_base64_VARIANT_ORIGINAL) == 0);
+
+    for (i = 0; i < 1000; i++) {
+        assert(sizeof buf1 >= 100);
+        bin_len = (size_t) randombytes_uniform(100);
+        bin = (unsigned char *) sodium_malloc(bin_len);
+        b64_len = (bin_len + 2U) / 3U * 4U + 1U;
+        assert(b64_len == sodium_base64_encoded_len(bin_len, sodium_base64_VARIANT_URLSAFE));
+        b64_ = (char *) sodium_malloc(b64_len);
+        randombytes_buf(bin, bin_len);
+        memcpy(buf1, bin, bin_len);
+        b64 = sodium_bin2base64(b64_, b64_len, bin, bin_len,
+                                sodium_base64_VARIANT_URLSAFE);
+        assert(b64 != NULL);
+        assert(sodium_base642bin(bin, bin_len + 10, b64, b64_len,
+                                 NULL, NULL, &b64_end,
+                                 sodium_base64_VARIANT_URLSAFE) == 0);
+        assert(b64_end == &b64[b64_len - 1]);
+        assert(memcmp(bin, buf1, bin_len) == 0);
+        sodium_free(bin);
+        sodium_free(b64_);
+    }
+    return 0;
+}

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

@@ -0,0 +1,28 @@
+30313233343536373839414243444546
+4:cafe6942
+dt1: 11
+4:cafe6942
+dt2: 2
+dt3: 11
+dt4: 11
+dt5: 11
+dt6: 11
++/DxMDEyMzQ1Njc4OUFCQ0RFRmFi
++/DxMDEyMzQ1Njc4OUFCQ0RFRmFiYw
+-_DxMDEyMzQ1Njc4OUFCQ0RFRmFi
+-_DxMDEyMzQ1Njc4OUFCQ0RFRmFiYw
+
+YQ==
+YWI=
+YWJj
+
+YQ
+YWI
+YWJj
+[]
+[BpcyBhIGpvdXJu
+ZXkgaW50by Bzb3VuZA==]
+[This is a journey into sound]
+[This is a journ]
+[
+ZXkgaW50by Bzb3VuZA==]

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

@@ -0,0 +1,41 @@
+
+#define TEST_NAME "core1"
+#include "cmptest.h"
+
+static unsigned char shared[32] = { 0x4a, 0x5d, 0x9d, 0x5b, 0xa4, 0xce, 0x2d,
+                                    0xe1, 0x72, 0x8e, 0x3b, 0xf4, 0x80, 0x35,
+                                    0x0f, 0x25, 0xe0, 0x7e, 0x21, 0xc9, 0x47,
+                                    0xd1, 0x9e, 0x33, 0x76, 0xf0, 0x9b, 0x3c,
+                                    0x1e, 0x16, 0x17, 0x42 };
+
+static unsigned char zero[32];
+
+static unsigned char c[16] = { 0x65, 0x78, 0x70, 0x61, 0x6e, 0x64, 0x20, 0x33,
+                               0x32, 0x2d, 0x62, 0x79, 0x74, 0x65, 0x20, 0x6b };
+
+static unsigned char firstkey[32];
+
+int
+main(void)
+{
+    int i;
+
+    crypto_core_hsalsa20(firstkey, zero, shared, c);
+    for (i = 0; i < 32; ++i) {
+        if (i > 0) {
+            printf(",");
+        } else {
+            printf(" ");
+        }
+        printf("0x%02x", (unsigned int) firstkey[i]);
+        if (i % 8 == 7) {
+            printf("\n");
+        }
+    }
+    assert(crypto_core_hsalsa20_outputbytes() > 0U);
+    assert(crypto_core_hsalsa20_inputbytes() > 0U);
+    assert(crypto_core_hsalsa20_keybytes() > 0U);
+    assert(crypto_core_hsalsa20_constbytes() > 0U);
+
+    return 0;
+}

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

@@ -0,0 +1,4 @@
+ 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

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

@@ -0,0 +1,38 @@
+
+#define TEST_NAME "core2"
+#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 nonceprefix[16] = { 0x69, 0x69, 0x6e, 0xe9, 0x55, 0xb6,
+                                         0x2b, 0x73, 0xcd, 0x62, 0xbd, 0xa8,
+                                         0x75, 0xfc, 0x73, 0xd6 };
+
+static unsigned char c[16] = { 0x65, 0x78, 0x70, 0x61, 0x6e, 0x64, 0x20, 0x33,
+                               0x32, 0x2d, 0x62, 0x79, 0x74, 0x65, 0x20, 0x6b };
+
+static unsigned char secondkey[32];
+
+int
+main(void)
+{
+    int i;
+
+    crypto_core_hsalsa20(secondkey, nonceprefix, firstkey, c);
+    for (i = 0; i < 32; ++i) {
+        if (i > 0) {
+            printf(",");
+        } else {
+            printf(" ");
+        }
+        printf("0x%02x", (unsigned int) secondkey[i]);
+        if (i % 8 == 7) {
+            printf("\n");
+        }
+    }
+    return 0;
+}

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

@@ -0,0 +1,4 @@
+ 0xdc,0x90,0x8d,0xda,0x0b,0x93,0x44,0xa9
+,0x53,0x62,0x9b,0x73,0x38,0x20,0x77,0x88
+,0x80,0xf3,0xce,0xb4,0x21,0xbb,0x61,0xb9
+,0x1c,0xbd,0x4c,0x3e,0x66,0x25,0x6c,0xe4

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

@@ -0,0 +1,115 @@
+
+#define TEST_NAME "core3"
+#include "cmptest.h"
+
+static unsigned char SECONDKEY[32] = { 0xdc, 0x90, 0x8d, 0xda, 0x0b, 0x93, 0x44,
+                                       0xa9, 0x53, 0x62, 0x9b, 0x73, 0x38, 0x20,
+                                       0x77, 0x88, 0x80, 0xf3, 0xce, 0xb4, 0x21,
+                                       0xbb, 0x61, 0xb9, 0x1c, 0xbd, 0x4c, 0x3e,
+                                       0x66, 0x25, 0x6c, 0xe4 };
+
+static unsigned char NONCESUFFIX[8] = { 0x82, 0x19, 0xe0, 0x03,
+                                        0x6b, 0x7a, 0x0b, 0x37 };
+
+static unsigned char C[16] = { 0x65, 0x78, 0x70, 0x61, 0x6e, 0x64, 0x20, 0x33,
+                               0x32, 0x2d, 0x62, 0x79, 0x74, 0x65, 0x20, 0x6b };
+
+int
+main(void)
+{
+    unsigned char *secondkey;
+    unsigned char *c;
+    unsigned char *noncesuffix;
+    unsigned char *in;
+    unsigned char *output;
+    unsigned char *h;
+    size_t         output_len = 64 * 256 * 256;
+    size_t         pos = 0;
+    int            i;
+
+    pos = 0;
+    secondkey = (unsigned char *) sodium_malloc(32);
+    memcpy(secondkey, SECONDKEY, 32);
+    noncesuffix = (unsigned char *) sodium_malloc(8);
+    memcpy(noncesuffix, NONCESUFFIX, 8);
+    c = (unsigned char *) sodium_malloc(16);
+    memcpy(c, C, 16);
+    in = (unsigned char *) sodium_malloc(16);
+    output = (unsigned char *) sodium_malloc(output_len);
+    h = (unsigned char *) sodium_malloc(32);
+
+    for (i = 0; i < 8; i++) {
+        in[i] = noncesuffix[i];
+    }
+    for (; i < 16; i++) {
+        in[i] = 0;
+    }
+    do {
+        do {
+            crypto_core_salsa20(output + pos, in, secondkey, c);
+            pos += 64;
+            in[8]++;
+        } while (in[8] != 0);
+        in[9]++;
+    } while (in[9] != 0);
+
+    crypto_hash_sha256(h, output, output_len);
+
+    for (i = 0; i < 32; ++i) {
+        printf("%02x", h[i]);
+    }
+    printf("\n");
+
+#ifndef SODIUM_LIBRARY_MINIMAL
+    pos = 0;
+    do {
+        do {
+            crypto_core_salsa2012(output + pos, in, secondkey, c);
+            pos += 64;
+            in[8]++;
+        } while (in[8] != 0);
+        in[9]++;
+    } while (in[9] != 0);
+
+    crypto_hash_sha256(h, output, output_len);
+
+    for (i = 0; i < 32; ++i) {
+        printf("%02x", h[i]);
+    }
+    printf("\n");
+
+    pos = 0;
+    do {
+        do {
+            crypto_core_salsa208(output + pos, in, secondkey, c);
+            pos += 64;
+            in[8]++;
+        } while (in[8] != 0);
+        in[9]++;
+    } while (in[9] != 0);
+
+    crypto_hash_sha256(h, output, output_len);
+
+    for (i = 0; i < 32; ++i) {
+        printf("%02x", h[i]);
+    }
+    printf("\n");
+#else
+    printf("a4e3147dddd2ba7775939b50208a22eb3277d4e4bad8a1cfbc999c6bd392b638\n"
+           "017421baa9959cbe894bd003ec87938254f47c1e757eb66cf89c353d0c2b68de\n");
+#endif
+
+    sodium_free(h);
+    sodium_free(output);
+    sodium_free(in);
+    sodium_free(c);
+    sodium_free(noncesuffix);
+    sodium_free(secondkey);
+
+    assert(crypto_core_salsa20_outputbytes() == crypto_core_salsa20_OUTPUTBYTES);
+    assert(crypto_core_salsa20_inputbytes() == crypto_core_salsa20_INPUTBYTES);
+    assert(crypto_core_salsa20_keybytes() == crypto_core_salsa20_KEYBYTES);
+    assert(crypto_core_salsa20_constbytes() == crypto_core_salsa20_CONSTBYTES);
+
+    return 0;
+}

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

@@ -0,0 +1,3 @@
+662b9d0e3463029156069b12f918691a98f7dfb2ca0393c96bbfc6b1fbd630a2
+a4e3147dddd2ba7775939b50208a22eb3277d4e4bad8a1cfbc999c6bd392b638
+017421baa9959cbe894bd003ec87938254f47c1e757eb66cf89c353d0c2b68de

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

@@ -0,0 +1,36 @@
+
+#define TEST_NAME "core4"
+#include "cmptest.h"
+
+static unsigned char k[32] = { 1,   2,   3,   4,   5,   6,   7,   8,
+                               9,   10,  11,  12,  13,  14,  15,  16,
+                               201, 202, 203, 204, 205, 206, 207, 208,
+                               209, 210, 211, 212, 213, 214, 215, 216 };
+
+static unsigned char in[16] = { 101, 102, 103, 104, 105, 106, 107, 108,
+                                109, 110, 111, 112, 113, 114, 115, 116 };
+
+static unsigned char c[16] = { 101, 120, 112, 97,  110, 100, 32, 51,
+                               50,  45,  98,  121, 116, 101, 32, 107 };
+
+static unsigned char out[64];
+
+int
+main(void)
+{
+    int i;
+
+    crypto_core_salsa20(out, in, k, c);
+    for (i = 0; i < 64; ++i) {
+        if (i > 0) {
+            printf(",");
+        } else {
+            printf(" ");
+        }
+        printf("%3u", (unsigned int) out[i]);
+        if (i % 8 == 7) {
+            printf("\n");
+        }
+    }
+    return 0;
+}

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

@@ -0,0 +1,8 @@
+  69, 37, 68, 39, 41, 15,107,193
+,255,139,122,  6,170,233,217, 98
+, 89,144,182,106, 21, 51,200, 65
+,239, 49,222, 34,215,114, 40,126
+,104,197,  7,225,197,153, 31,  2
+,102, 78, 76,176, 84,245,246,184
+,177,160,133,130,  6, 72,149,119
+,192,195,132,236,234,103,246, 74

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

@@ -0,0 +1,33 @@
+
+#define TEST_NAME "core5"
+#include "cmptest.h"
+
+static unsigned char k[32] = { 0xee, 0x30, 0x4f, 0xca, 0x27, 0x00, 0x8d, 0x8c,
+                               0x12, 0x6f, 0x90, 0x02, 0x79, 0x01, 0xd8, 0x0f,
+                               0x7f, 0x1d, 0x8b, 0x8d, 0xc9, 0x36, 0xcf, 0x3b,
+                               0x9f, 0x81, 0x96, 0x92, 0x82, 0x7e, 0x57, 0x77 };
+
+static unsigned char in[16] = {
+    0x81, 0x91, 0x8e, 0xf2, 0xa5, 0xe0, 0xda, 0x9b,
+    0x3e, 0x90, 0x60, 0x52, 0x1e, 0x4b, 0xb3, 0x52
+};
+
+static unsigned char c[16] = { 101, 120, 112, 97,  110, 100, 32, 51,
+                               50,  45,  98,  121, 116, 101, 32, 107 };
+
+unsigned char out[32];
+
+int
+main(void)
+{
+    int i;
+
+    crypto_core_hsalsa20(out, in, k, c);
+    for (i = 0; i < 32; ++i) {
+        printf(",0x%02x", (unsigned int) out[i]);
+        if (i % 8 == 7) {
+            printf("\n");
+        }
+    }
+    return 0;
+}

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

@@ -0,0 +1,4 @@
+,0xbc,0x1b,0x30,0xfc,0x07,0x2c,0xc1,0x40
+,0x75,0xe4,0xba,0xa7,0x31,0xb5,0xa8,0x45
+,0xea,0x9b,0x11,0xe9,0xa5,0x19,0x1f,0x94
+,0xe1,0x8c,0xba,0x8f,0xd8,0x21,0xa7,0xcd