laag-libsodium 1.0.16.0

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

@@ -0,0 +1,124 @@
+
+#define TEST_NAME "secretbox_easy"
+#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 m[131] = {
+    0xbe, 0x07, 0x5f, 0xc5, 0x3c, 0x81, 0xf2, 0xd5, 0xcf, 0x14, 0x13, 0x16,
+    0xeb, 0xeb, 0x0c, 0x7b, 0x52, 0x28, 0xc5, 0x2a, 0x4c, 0x62, 0xcb, 0xd4,
+    0x4b, 0x66, 0x84, 0x9b, 0x64, 0x24, 0x4f, 0xfc, 0xe5, 0xec, 0xba, 0xaf,
+    0x33, 0xbd, 0x75, 0x1a, 0x1a, 0xc7, 0x28, 0xd4, 0x5e, 0x6c, 0x61, 0x29,
+    0x6c, 0xdc, 0x3c, 0x01, 0x23, 0x35, 0x61, 0xf4, 0x1d, 0xb6, 0x6c, 0xce,
+    0x31, 0x4a, 0xdb, 0x31, 0x0e, 0x3b, 0xe8, 0x25, 0x0c, 0x46, 0xf0, 0x6d,
+    0xce, 0xea, 0x3a, 0x7f, 0xa1, 0x34, 0x80, 0x57, 0xe2, 0xf6, 0x55, 0x6a,
+    0xd6, 0xb1, 0x31, 0x8a, 0x02, 0x4a, 0x83, 0x8f, 0x21, 0xaf, 0x1f, 0xde,
+    0x04, 0x89, 0x77, 0xeb, 0x48, 0xf5, 0x9f, 0xfd, 0x49, 0x24, 0xca, 0x1c,
+    0x60, 0x90, 0x2e, 0x52, 0xf0, 0xa0, 0x89, 0xbc, 0x76, 0x89, 0x70, 0x40,
+    0xe0, 0x82, 0xf9, 0x37, 0x76, 0x38, 0x48, 0x64, 0x5e, 0x07, 0x05
+};
+
+int
+main(void)
+{
+    unsigned char *c;
+    unsigned char *mac;
+    size_t         i;
+
+    c   = (unsigned char *) sodium_malloc(131 + crypto_secretbox_MACBYTES + 1);
+    mac = (unsigned char *) sodium_malloc(crypto_secretbox_MACBYTES);
+    assert(c != NULL && mac != NULL);
+
+    crypto_secretbox_easy(c, m, 131, nonce, firstkey);
+    for (i = 0; i < 131 + crypto_secretbox_MACBYTES; ++i) {
+        printf(",0x%02x", (unsigned int) c[i]);
+    }
+    printf("\n");
+
+    crypto_secretbox_detached(c, mac, m, 131, nonce, firstkey);
+    for (i = 0; i < crypto_secretbox_MACBYTES; ++i) {
+        printf(",0x%02x", (unsigned int) mac[i]);
+    }
+    for (i = 0; i < 131; ++i) {
+        printf(",0x%02x", (unsigned int) c[i]);
+    }
+    printf("\n");
+
+    /* Same test, with c and m overlapping */
+
+    memcpy(c + 1, m, 131);
+    crypto_secretbox_easy(c, c + 1, 131, nonce, firstkey);
+    for (i = 0; i < 131 + crypto_secretbox_MACBYTES; ++i) {
+        printf(",0x%02x", (unsigned int) c[i]);
+    }
+    printf("\n");
+
+    memcpy(c, m, 131);
+    crypto_secretbox_easy(c + 1, c, 131, nonce, firstkey);
+    for (i = 0; i < 131 + crypto_secretbox_MACBYTES; ++i) {
+        printf(",0x%02x", (unsigned int) c[i + 1]);
+    }
+    printf("\n");
+
+    memcpy(c, m, 131);
+    crypto_secretbox_easy(c, c, 131, nonce, firstkey);
+    for (i = 0; i < 131 + crypto_secretbox_MACBYTES; ++i) {
+        printf(",0x%02x", (unsigned int) c[i]);
+    }
+    printf("\n");
+
+    assert(crypto_secretbox_easy(c, m, 0, nonce, firstkey) == 0);
+
+    /* Null message */
+
+    crypto_secretbox_easy(c, c, 0, nonce, firstkey);
+    for (i = 0; i < crypto_secretbox_MACBYTES + 1; ++i) {
+        printf(",0x%02x", (unsigned int) c[i]);
+    }
+    printf("\n");
+    if (crypto_secretbox_open_easy(c, c, crypto_secretbox_MACBYTES, nonce,
+                                   firstkey) != 0) {
+        printf("Null crypto_secretbox_open_easy() failed\n");
+    }
+    for (i = 0; i < crypto_secretbox_MACBYTES + 1; ++i) {
+        printf(",0x%02x", (unsigned int) c[i]);
+    }
+    printf("\n");
+    c[randombytes_uniform(crypto_secretbox_MACBYTES)]++;
+    if (crypto_secretbox_open_easy(c, c, crypto_secretbox_MACBYTES, nonce,
+                                   firstkey) != -1) {
+        printf("Null tampered crypto_secretbox_open_easy() failed\n");
+    }
+
+    /* No overlap, but buffers are next to each other */
+
+    memset(c, 0, 131 + crypto_secretbox_MACBYTES + 1);
+    memcpy(c, m, 20);
+    crypto_secretbox_easy(c, c + 10, 10, nonce, firstkey);
+    for (i = 0; i < 10 + crypto_secretbox_MACBYTES; ++i) {
+        printf(",0x%02x", (unsigned int) c[i]);
+    }
+    printf("\n");
+
+    memset(c, 0, 131 + crypto_secretbox_MACBYTES + 1);
+    memcpy(c, m, 20);
+    crypto_secretbox_easy(c + 10, c, 10, nonce, firstkey);
+    for (i = 0; i < 10 + crypto_secretbox_MACBYTES; ++i) {
+        printf(",0x%02x", (unsigned int) c[i]);
+    }
+    printf("\n");
+
+    sodium_free(mac);
+    sodium_free(c);
+
+    return 0;
+}

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

@@ -0,0 +1,9 @@
+,0xf3,0xff,0xc7,0x70,0x3f,0x94,0x00,0xe5,0x2a,0x7d,0xfb,0x4b,0x3d,0x33,0x05,0xd9,0x8e,0x99,0x3b,0x9f,0x48,0x68,0x12,0x73,0xc2,0x96,0x50,0xba,0x32,0xfc,0x76,0xce,0x48,0x33,0x2e,0xa7,0x16,0x4d,0x96,0xa4,0x47,0x6f,0xb8,0xc5,0x31,0xa1,0x18,0x6a,0xc0,0xdf,0xc1,0x7c,0x98,0xdc,0xe8,0x7b,0x4d,0xa7,0xf0,0x11,0xec,0x48,0xc9,0x72,0x71,0xd2,0xc2,0x0f,0x9b,0x92,0x8f,0xe2,0x27,0x0d,0x6f,0xb8,0x63,0xd5,0x17,0x38,0xb4,0x8e,0xee,0xe3,0x14,0xa7,0xcc,0x8a,0xb9,0x32,0x16,0x45,0x48,0xe5,0x26,0xae,0x90,0x22,0x43,0x68,0x51,0x7a,0xcf,0xea,0xbd,0x6b,0xb3,0x73,0x2b,0xc0,0xe9,0xda,0x99,0x83,0x2b,0x61,0xca,0x01,0xb6,0xde,0x56,0x24,0x4a,0x9e,0x88,0xd5,0xf9,0xb3,0x79,0x73,0xf6,0x22,0xa4,0x3d,0x14,0xa6,0x59,0x9b,0x1f,0x65,0x4c,0xb4,0x5a,0x74,0xe3,0x55,0xa5
+,0xf3,0xff,0xc7,0x70,0x3f,0x94,0x00,0xe5,0x2a,0x7d,0xfb,0x4b,0x3d,0x33,0x05,0xd9,0x8e,0x99,0x3b,0x9f,0x48,0x68,0x12,0x73,0xc2,0x96,0x50,0xba,0x32,0xfc,0x76,0xce,0x48,0x33,0x2e,0xa7,0x16,0x4d,0x96,0xa4,0x47,0x6f,0xb8,0xc5,0x31,0xa1,0x18,0x6a,0xc0,0xdf,0xc1,0x7c,0x98,0xdc,0xe8,0x7b,0x4d,0xa7,0xf0,0x11,0xec,0x48,0xc9,0x72,0x71,0xd2,0xc2,0x0f,0x9b,0x92,0x8f,0xe2,0x27,0x0d,0x6f,0xb8,0x63,0xd5,0x17,0x38,0xb4,0x8e,0xee,0xe3,0x14,0xa7,0xcc,0x8a,0xb9,0x32,0x16,0x45,0x48,0xe5,0x26,0xae,0x90,0x22,0x43,0x68,0x51,0x7a,0xcf,0xea,0xbd,0x6b,0xb3,0x73,0x2b,0xc0,0xe9,0xda,0x99,0x83,0x2b,0x61,0xca,0x01,0xb6,0xde,0x56,0x24,0x4a,0x9e,0x88,0xd5,0xf9,0xb3,0x79,0x73,0xf6,0x22,0xa4,0x3d,0x14,0xa6,0x59,0x9b,0x1f,0x65,0x4c,0xb4,0x5a,0x74,0xe3,0x55,0xa5
+,0xf3,0xff,0xc7,0x70,0x3f,0x94,0x00,0xe5,0x2a,0x7d,0xfb,0x4b,0x3d,0x33,0x05,0xd9,0x8e,0x99,0x3b,0x9f,0x48,0x68,0x12,0x73,0xc2,0x96,0x50,0xba,0x32,0xfc,0x76,0xce,0x48,0x33,0x2e,0xa7,0x16,0x4d,0x96,0xa4,0x47,0x6f,0xb8,0xc5,0x31,0xa1,0x18,0x6a,0xc0,0xdf,0xc1,0x7c,0x98,0xdc,0xe8,0x7b,0x4d,0xa7,0xf0,0x11,0xec,0x48,0xc9,0x72,0x71,0xd2,0xc2,0x0f,0x9b,0x92,0x8f,0xe2,0x27,0x0d,0x6f,0xb8,0x63,0xd5,0x17,0x38,0xb4,0x8e,0xee,0xe3,0x14,0xa7,0xcc,0x8a,0xb9,0x32,0x16,0x45,0x48,0xe5,0x26,0xae,0x90,0x22,0x43,0x68,0x51,0x7a,0xcf,0xea,0xbd,0x6b,0xb3,0x73,0x2b,0xc0,0xe9,0xda,0x99,0x83,0x2b,0x61,0xca,0x01,0xb6,0xde,0x56,0x24,0x4a,0x9e,0x88,0xd5,0xf9,0xb3,0x79,0x73,0xf6,0x22,0xa4,0x3d,0x14,0xa6,0x59,0x9b,0x1f,0x65,0x4c,0xb4,0x5a,0x74,0xe3,0x55,0xa5
+,0xf3,0xff,0xc7,0x70,0x3f,0x94,0x00,0xe5,0x2a,0x7d,0xfb,0x4b,0x3d,0x33,0x05,0xd9,0x8e,0x99,0x3b,0x9f,0x48,0x68,0x12,0x73,0xc2,0x96,0x50,0xba,0x32,0xfc,0x76,0xce,0x48,0x33,0x2e,0xa7,0x16,0x4d,0x96,0xa4,0x47,0x6f,0xb8,0xc5,0x31,0xa1,0x18,0x6a,0xc0,0xdf,0xc1,0x7c,0x98,0xdc,0xe8,0x7b,0x4d,0xa7,0xf0,0x11,0xec,0x48,0xc9,0x72,0x71,0xd2,0xc2,0x0f,0x9b,0x92,0x8f,0xe2,0x27,0x0d,0x6f,0xb8,0x63,0xd5,0x17,0x38,0xb4,0x8e,0xee,0xe3,0x14,0xa7,0xcc,0x8a,0xb9,0x32,0x16,0x45,0x48,0xe5,0x26,0xae,0x90,0x22,0x43,0x68,0x51,0x7a,0xcf,0xea,0xbd,0x6b,0xb3,0x73,0x2b,0xc0,0xe9,0xda,0x99,0x83,0x2b,0x61,0xca,0x01,0xb6,0xde,0x56,0x24,0x4a,0x9e,0x88,0xd5,0xf9,0xb3,0x79,0x73,0xf6,0x22,0xa4,0x3d,0x14,0xa6,0x59,0x9b,0x1f,0x65,0x4c,0xb4,0x5a,0x74,0xe3,0x55,0xa5
+,0xf3,0xff,0xc7,0x70,0x3f,0x94,0x00,0xe5,0x2a,0x7d,0xfb,0x4b,0x3d,0x33,0x05,0xd9,0x8e,0x99,0x3b,0x9f,0x48,0x68,0x12,0x73,0xc2,0x96,0x50,0xba,0x32,0xfc,0x76,0xce,0x48,0x33,0x2e,0xa7,0x16,0x4d,0x96,0xa4,0x47,0x6f,0xb8,0xc5,0x31,0xa1,0x18,0x6a,0xc0,0xdf,0xc1,0x7c,0x98,0xdc,0xe8,0x7b,0x4d,0xa7,0xf0,0x11,0xec,0x48,0xc9,0x72,0x71,0xd2,0xc2,0x0f,0x9b,0x92,0x8f,0xe2,0x27,0x0d,0x6f,0xb8,0x63,0xd5,0x17,0x38,0xb4,0x8e,0xee,0xe3,0x14,0xa7,0xcc,0x8a,0xb9,0x32,0x16,0x45,0x48,0xe5,0x26,0xae,0x90,0x22,0x43,0x68,0x51,0x7a,0xcf,0xea,0xbd,0x6b,0xb3,0x73,0x2b,0xc0,0xe9,0xda,0x99,0x83,0x2b,0x61,0xca,0x01,0xb6,0xde,0x56,0x24,0x4a,0x9e,0x88,0xd5,0xf9,0xb3,0x79,0x73,0xf6,0x22,0xa4,0x3d,0x14,0xa6,0x59,0x9b,0x1f,0x65,0x4c,0xb4,0x5a,0x74,0xe3,0x55,0xa5
+,0x25,0x39,0x12,0x1d,0x8e,0x23,0x4e,0x65,0x2d,0x65,0x1f,0xa4,0xc8,0xcf,0xf8,0x80,0x8e
+,0x25,0x39,0x12,0x1d,0x8e,0x23,0x4e,0x65,0x2d,0x65,0x1f,0xa4,0xc8,0xcf,0xf8,0x80,0x8e
+,0x8c,0xf3,0x90,0x57,0xc9,0xbc,0xf2,0xba,0x98,0x87,0xfb,0x15,0x9f,0x21,0x0c,0xd8,0x23,0x88,0x8f,0xb1,0x78,0x92,0xb2,0x8e,0xc8,0xa8
+,0xbe,0x07,0x5f,0xc5,0x3c,0x81,0xf2,0xd5,0xcf,0x14,0xd2,0xe8,0xe8,0x1a,0xac,0xd2,0xba,0x1b,0xaa,0x60,0x99,0xe3,0xd9,0x63,0x56,0x18

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

@@ -0,0 +1,72 @@
+
+#define TEST_NAME "secretbox_easy2"
+#include "cmptest.h"
+
+int
+main(void)
+{
+    unsigned char *m;
+    unsigned char *m2;
+    unsigned char *c;
+    unsigned char *nonce;
+    unsigned char *k;
+    unsigned char *mac;
+    size_t         mlen;
+    size_t         i;
+
+    mlen  = (size_t) randombytes_uniform((uint32_t) 10000) + 1U;
+    m     = (unsigned char *) sodium_malloc(mlen);
+    m2    = (unsigned char *) sodium_malloc(mlen);
+    c     = (unsigned char *) sodium_malloc(crypto_secretbox_MACBYTES + mlen);
+    nonce = (unsigned char *) sodium_malloc(crypto_secretbox_NONCEBYTES);
+    k     = (unsigned char *) sodium_malloc(crypto_secretbox_KEYBYTES);
+    mac   = (unsigned char *) sodium_malloc(crypto_secretbox_MACBYTES);
+    crypto_secretbox_keygen(k);
+    randombytes_buf(m, mlen);
+    randombytes_buf(nonce, crypto_secretbox_NONCEBYTES);
+    crypto_secretbox_easy(c, m, (unsigned long long) mlen, nonce, k);
+    if (crypto_secretbox_open_easy(
+            m2, c, (unsigned long long) mlen + crypto_secretbox_MACBYTES, nonce,
+            k) != 0) {
+        printf("crypto_secretbox_open_easy() failed\n");
+    }
+    printf("%d\n", memcmp(m, m2, mlen));
+
+    for (i = 0; i < mlen + crypto_secretbox_MACBYTES - 1; i++) {
+        if (crypto_secretbox_open_easy(m2, c, (unsigned long long) i, nonce,
+                                       k) == 0) {
+            printf("short open() should have failed\n");
+            return 1;
+        }
+    }
+    crypto_secretbox_detached(c, mac, m, (unsigned long long) mlen, nonce, k);
+    if (crypto_secretbox_open_detached(NULL, c, mac, (unsigned long long) mlen,
+                                       nonce, k) != 0) {
+        printf("crypto_secretbox_open_detached() with a NULL message pointer failed\n");
+    }
+    if (crypto_secretbox_open_detached(m2, c, mac, (unsigned long long) mlen,
+                                       nonce, k) != 0) {
+        printf("crypto_secretbox_open_detached() failed\n");
+    }
+    printf("%d\n", memcmp(m, m2, mlen));
+
+    memcpy(c, m, mlen);
+    crypto_secretbox_easy(c, c, (unsigned long long) mlen, nonce, k);
+    printf("%d\n", memcmp(m, c, mlen) == 0);
+    printf("%d\n", memcmp(m, c + crypto_secretbox_MACBYTES, mlen) == 0);
+    if (crypto_secretbox_open_easy(
+            c, c, (unsigned long long) mlen + crypto_secretbox_MACBYTES, nonce,
+            k) != 0) {
+        printf("crypto_secretbox_open_easy() failed\n");
+    }
+    printf("%d\n", memcmp(m, c, mlen));
+
+    sodium_free(m);
+    sodium_free(m2);
+    sodium_free(c);
+    sodium_free(nonce);
+    sodium_free(k);
+    sodium_free(mac);
+
+    return 0;
+}

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

@@ -0,0 +1,5 @@
+0
+0
+0
+0
+0

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

@@ -0,0 +1,329 @@
+
+#define TEST_NAME "secretstream"
+#include "cmptest.h"
+
+int
+main(void)
+{
+    crypto_secretstream_xchacha20poly1305_state *state, *statesave;
+    crypto_secretstream_xchacha20poly1305_state state_copy;
+    unsigned char      *ad;
+    unsigned char      *header;
+    unsigned char      *k;
+    unsigned char      *c1, *c2, *c3, *csave;
+    unsigned char      *m1, *m2, *m3;
+    unsigned char      *m1_, *m2_, *m3_;
+    unsigned long long  res_len;
+    size_t              ad_len;
+    size_t              m1_len, m2_len, m3_len;
+    int                 ret;
+    unsigned char       tag;
+
+    state = (crypto_secretstream_xchacha20poly1305_state *)
+        sodium_malloc(crypto_secretstream_xchacha20poly1305_statebytes());
+    statesave = (crypto_secretstream_xchacha20poly1305_state *)
+        sodium_malloc(crypto_secretstream_xchacha20poly1305_statebytes());
+    header = (unsigned char *)
+        sodium_malloc(crypto_secretstream_xchacha20poly1305_HEADERBYTES);
+
+    ad_len = randombytes_uniform(100);
+    m1_len = randombytes_uniform(1000);
+    m2_len = randombytes_uniform(1000);
+    m3_len = randombytes_uniform(1000);
+
+    c1 = (unsigned char *)
+        sodium_malloc(m1_len + crypto_secretstream_xchacha20poly1305_ABYTES);
+    c2 = (unsigned char *)
+        sodium_malloc(m2_len + crypto_secretstream_xchacha20poly1305_ABYTES);
+    c3 = (unsigned char *)
+        sodium_malloc(m3_len + crypto_secretstream_xchacha20poly1305_ABYTES);
+    csave = (unsigned char *)
+        sodium_malloc((m1_len | m2_len | m3_len) + crypto_secretstream_xchacha20poly1305_ABYTES);
+
+    ad  = (unsigned char *) sodium_malloc(ad_len);
+    m1  = (unsigned char *) sodium_malloc(m1_len);
+    m2  = (unsigned char *) sodium_malloc(m2_len);
+    m3  = (unsigned char *) sodium_malloc(m3_len);
+    m1_ = (unsigned char *) sodium_malloc(m1_len);
+    m2_ = (unsigned char *) sodium_malloc(m2_len);
+    m3_ = (unsigned char *) sodium_malloc(m3_len);
+
+    randombytes_buf(ad, ad_len);
+
+    randombytes_buf(m1, m1_len);
+    memcpy(m1_, m1, m1_len);
+    randombytes_buf(m2, m2_len);
+    memcpy(m2_, m2, m2_len);
+    randombytes_buf(m3, m3_len);
+    memcpy(m3_, m3, m3_len);
+
+    k = (unsigned char *)
+        sodium_malloc(crypto_secretstream_xchacha20poly1305_KEYBYTES);
+    crypto_secretstream_xchacha20poly1305_keygen(k);
+
+    /* push */
+
+    ret = crypto_secretstream_xchacha20poly1305_init_push(state, header, k);
+    assert(ret == 0);
+
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c1, &res_len, m1, m1_len, NULL, 0, 0);
+    assert(ret == 0);
+    assert(res_len == m1_len + crypto_secretstream_xchacha20poly1305_ABYTES);
+
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c2, NULL, m2, m2_len, ad, 0, 0);
+    assert(ret == 0);
+
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c3, NULL, m3, m3_len, ad, ad_len,
+         crypto_secretstream_xchacha20poly1305_TAG_FINAL);
+    assert(ret == 0);
+
+    /* pull */
+
+    ret = crypto_secretstream_xchacha20poly1305_init_pull(state, header, k);
+    assert(ret == 0);
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m1, &res_len, &tag,
+         c1, m1_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == 0);
+    assert(tag == 0);
+    assert(memcmp(m1, m1_, m1_len) == 0);
+    assert(res_len == m1_len);
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m2, NULL, &tag,
+         c2, m2_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == 0);
+    assert(tag == 0);
+    assert(memcmp(m2, m2_, m2_len) == 0);
+
+    if (ad_len > 0) {
+        ret = crypto_secretstream_xchacha20poly1305_pull
+            (state, m3, NULL, &tag,
+             c3, m3_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+        assert(ret == -1);
+    }
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m3, NULL, &tag,
+         c3, m3_len + crypto_secretstream_xchacha20poly1305_ABYTES, ad, ad_len);
+    assert(ret == 0);
+    assert(tag == crypto_secretstream_xchacha20poly1305_TAG_FINAL);
+    assert(memcmp(m3, m3_, m3_len) == 0);
+
+    /* previous with FINAL tag */
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m3, NULL, &tag,
+         c3, m3_len + crypto_secretstream_xchacha20poly1305_ABYTES, ad, ad_len);
+    assert(ret == -1);
+
+    /* previous without a tag */
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m2, NULL, &tag,
+         c2, m2_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == -1);
+
+    /* short ciphertext */
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m2, NULL, &tag, c2,
+         randombytes_uniform(crypto_secretstream_xchacha20poly1305_ABYTES),
+         NULL, 0);
+    assert(ret == -1);
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m2, NULL, &tag, c2, 0, NULL, 0);
+    assert(ret == -1);
+
+    /* empty ciphertext */
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m2, NULL, &tag, c2,
+         crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == -1);
+
+    /* without explicit rekeying */
+
+    ret = crypto_secretstream_xchacha20poly1305_init_push(state, header, k);
+    assert(ret == 0);
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c1, NULL, m1, m1_len, NULL, 0, 0);
+    assert(ret == 0);
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c2, NULL, m2, m2_len, NULL, 0, 0);
+    assert(ret == 0);
+
+    ret = crypto_secretstream_xchacha20poly1305_init_pull(state, header, k);
+    assert(ret == 0);
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m1, NULL, &tag,
+         c1, m1_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == 0);
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m2, NULL, &tag,
+         c2, m2_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == 0);
+
+    /* with explicit rekeying */
+
+    ret = crypto_secretstream_xchacha20poly1305_init_push(state, header, k);
+    assert(ret == 0);
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c1, NULL, m1, m1_len, NULL, 0, 0);
+    assert(ret == 0);
+
+    crypto_secretstream_xchacha20poly1305_rekey(state);
+
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c2, NULL, m2, m2_len, NULL, 0, 0);
+    assert(ret == 0);
+
+    ret = crypto_secretstream_xchacha20poly1305_init_pull(state, header, k);
+    assert(ret == 0);
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m1, NULL, &tag,
+         c1, m1_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == 0);
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m2, NULL, &tag,
+         c2, m2_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == -1);
+
+    crypto_secretstream_xchacha20poly1305_rekey(state);
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m2, NULL, &tag,
+         c2, m2_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == 0);
+
+    /* with explicit rekeying using TAG_REKEY */
+
+    ret = crypto_secretstream_xchacha20poly1305_init_push(state, header, k);
+    assert(ret == 0);
+
+    memcpy(statesave, state, sizeof *state);
+
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c1, NULL, m1, m1_len, NULL, 0, crypto_secretstream_xchacha20poly1305_TAG_REKEY);
+    assert(ret == 0);
+
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c2, NULL, m2, m2_len, NULL, 0, 0);
+    assert(ret == 0);
+
+    memcpy(csave, c2, m2_len + crypto_secretstream_xchacha20poly1305_ABYTES);
+
+    ret = crypto_secretstream_xchacha20poly1305_init_pull(state, header, k);
+    assert(ret == 0);
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m1, NULL, &tag,
+         c1, m1_len + crypto_secretstream_xchacha20poly1305_ABYTES, &tag, 0);
+    assert(ret == 0);
+    assert(tag == crypto_secretstream_xchacha20poly1305_TAG_REKEY);
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m2, NULL, &tag,
+         c2, m2_len + crypto_secretstream_xchacha20poly1305_ABYTES, &tag, 0);
+    assert(ret == 0);
+    assert(tag == 0);
+
+    memcpy(state, statesave, sizeof *state);
+
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c1, NULL, m1, m1_len, NULL, 0, 0);
+    assert(ret == 0);
+
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c2, NULL, m2, m2_len, NULL, 0, 0);
+    assert(ret == 0);
+
+    assert(memcmp(csave, c2, m2_len + crypto_secretstream_xchacha20poly1305_ABYTES) != 0);
+
+    /* New stream */
+
+    ret = crypto_secretstream_xchacha20poly1305_init_push(state, header, k);
+    assert(ret == 0);
+
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c1, &res_len, m1, m1_len, NULL, 0,
+         crypto_secretstream_xchacha20poly1305_TAG_PUSH);
+    assert(ret == 0);
+    assert(res_len == m1_len + crypto_secretstream_xchacha20poly1305_ABYTES);
+
+    /* Force a counter overflow, check that the key has been updated
+     * even though the tag was not changed to REKEY */
+
+    memset(state->nonce, 0xff, 4U);
+    state_copy = *state;
+
+    ret = crypto_secretstream_xchacha20poly1305_push
+        (state, c2, NULL, m2, m2_len, ad, 0, 0);
+    assert(ret == 0);
+
+    assert(memcmp(state_copy.k, state->k, sizeof state->k) != 0);
+    assert(memcmp(state_copy.nonce, state->nonce, sizeof state->nonce) != 0);
+    assert(state->nonce[0] == 1U);
+    assert(sodium_is_zero(state->nonce + 1, 3U));
+
+    ret = crypto_secretstream_xchacha20poly1305_init_pull(state, header, k);
+    assert(ret == 0);
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m1, &res_len, &tag,
+         c1, m1_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == 0);
+    assert(tag == crypto_secretstream_xchacha20poly1305_TAG_PUSH);
+    assert(memcmp(m1, m1_, m1_len) == 0);
+    assert(res_len == m1_len);
+
+    memset(state->nonce, 0xff, 4U);
+
+    ret = crypto_secretstream_xchacha20poly1305_pull
+        (state, m2, NULL, &tag,
+         c2, m2_len + crypto_secretstream_xchacha20poly1305_ABYTES, NULL, 0);
+    assert(ret == 0);
+    assert(tag == 0);
+    assert(memcmp(m2, m2_, m2_len) == 0);
+
+    sodium_free(m3_);
+    sodium_free(m2_);
+    sodium_free(m1_);
+    sodium_free(m3);
+    sodium_free(m2);
+    sodium_free(m1);
+    sodium_free(ad);
+    sodium_free(csave);
+    sodium_free(c3);
+    sodium_free(c2);
+    sodium_free(c1);
+    sodium_free(k);
+    sodium_free(header);
+    sodium_free(statesave);
+    sodium_free(state);
+
+    assert(crypto_secretstream_xchacha20poly1305_abytes() ==
+           crypto_secretstream_xchacha20poly1305_ABYTES);
+    assert(crypto_secretstream_xchacha20poly1305_headerbytes() ==
+           crypto_secretstream_xchacha20poly1305_HEADERBYTES);
+    assert(crypto_secretstream_xchacha20poly1305_keybytes() ==
+           crypto_secretstream_xchacha20poly1305_KEYBYTES);
+    assert(crypto_secretstream_xchacha20poly1305_messagebytes_max() ==
+           crypto_secretstream_xchacha20poly1305_MESSAGEBYTES_MAX);
+
+    assert(crypto_secretstream_xchacha20poly1305_tag_message() ==
+           crypto_secretstream_xchacha20poly1305_TAG_MESSAGE);
+    assert(crypto_secretstream_xchacha20poly1305_tag_push() ==
+           crypto_secretstream_xchacha20poly1305_TAG_PUSH);
+    assert(crypto_secretstream_xchacha20poly1305_tag_rekey() ==
+           crypto_secretstream_xchacha20poly1305_TAG_REKEY);
+    assert(crypto_secretstream_xchacha20poly1305_tag_final() ==
+           crypto_secretstream_xchacha20poly1305_TAG_FINAL);
+
+    printf("OK\n");
+
+    return 0;
+}

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

@@ -0,0 +1 @@
+OK

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

@@ -0,0 +1,35 @@
+
+#define TEST_NAME "shorthash"
+#include "cmptest.h"
+
+#define MAXLEN 64
+
+int
+main(void)
+{
+    unsigned char in[MAXLEN];
+    unsigned char out[crypto_shorthash_BYTES];
+    unsigned char k[crypto_shorthash_KEYBYTES];
+    size_t        i;
+    size_t        j;
+
+    for (i = 0; i < crypto_shorthash_KEYBYTES; ++i) {
+        k[i] = (unsigned char) i;
+    }
+    for (i = 0; i < MAXLEN; ++i) {
+        in[i] = (unsigned char) i;
+        crypto_shorthash(out, in, (unsigned long long) i, k);
+        for (j = 0; j < crypto_shorthash_BYTES; ++j) {
+            printf("%02x", (unsigned int) out[j]);
+        }
+        printf("\n");
+    }
+    assert(crypto_shorthash_bytes() > 0);
+    assert(crypto_shorthash_keybytes() > 0);
+    assert(strcmp(crypto_shorthash_primitive(), "siphash24") == 0);
+    assert(crypto_shorthash_bytes() == crypto_shorthash_siphash24_bytes());
+    assert(crypto_shorthash_keybytes() ==
+           crypto_shorthash_siphash24_keybytes());
+
+    return 0;
+}

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

@@ -0,0 +1,64 @@
+310e0edd47db6f72
+fd67dc93c539f874
+5a4fa9d909806c0d
+2d7efbd796666785
+b7877127e09427cf
+8da699cd64557618
+cee3fe586e46c9cb
+37d1018bf50002ab
+6224939a79f5f593
+b0e4a90bdf82009e
+f3b9dd94c5bb5d7a
+a7ad6b22462fb3f4
+fbe50e86bc8f1e75
+903d84c02756ea14
+eef27a8e90ca23f7
+e545be4961ca29a1
+db9bc2577fcc2a3f
+9447be2cf5e99a69
+9cd38d96f0b3c14b
+bd6179a71dc96dbb
+98eea21af25cd6be
+c7673b2eb0cbf2d0
+883ea3e395675393
+c8ce5ccd8c030ca8
+94af49f6c650adb8
+eab8858ade92e1bc
+f315bb5bb835d817
+adcf6b0763612e2f
+a5c91da7acaa4dde
+716595876650a2a6
+28ef495c53a387ad
+42c341d8fa92d832
+ce7cf2722f512771
+e37859f94623f3a7
+381205bb1ab0e012
+ae97a10fd434e015
+b4a31508beff4d31
+81396229f0907902
+4d0cf49ee5d4dcca
+5c73336a76d8bf9a
+d0a704536ba93e0e
+925958fcd6420cad
+a915c29bc8067318
+952b79f3bc0aa6d4
+f21df2e41d4535f9
+87577519048f53a9
+10a56cf5dfcd9adb
+eb75095ccd986cd0
+51a9cb9ecba312e6
+96afadfc2ce666c7
+72fe52975a4364ee
+5a1645b276d592a1
+b274cb8ebf87870a
+6f9bb4203de7b381
+eaecb2a30b22a87f
+9924a43cc1315724
+bd838d3aafbf8db7
+0b1a2a3265d51aea
+135079a3231ce660
+932b2846e4d70666
+e1915f5cb1eca46c
+f325965ca16d629f
+575ff28e60381be5
+724506eb4c328a95