rbnacl-libsodium 1.0.13 → 1.0.15

data/vendor/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/libsodium/test/default/core3.c

@@ -2,43 +2,70 @@
 #define TEST_NAME "core3"
 #include "cmptest.h"
 
-static unsigned char secondkey[32] = { 0xdc, 0x90, 0x8d, 0xda, 0x0b, 0x93, 0x44,
+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,
+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,
+static unsigned char C[16] = { 0x65, 0x78, 0x70, 0x61, 0x6e, 0x64, 0x20, 0x33,
                                0x32, 0x2d, 0x62, 0x79, 0x74, 0x65, 0x20, 0x6b };
 
-static unsigned char in[16];
-
-static unsigned char output[64 * 256 * 256];
-
-static unsigned char h[32];
-
 int
 main(void)
 {
-    int       i;
-    long long pos = 0;
+    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;
 
-    for (i    = 0; i < 8; ++i)
+    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;
-        } while (++in[8]);
-    } while (++in[9]);
-    crypto_hash_sha256(h, output, sizeof output);
+            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");
+
+    sodium_free(h);
+    sodium_free(output);
+    sodium_free(in);
+    sodium_free(c);
+    sodium_free(noncesuffix);
+    sodium_free(secondkey);
+
     assert(crypto_core_salsa20_outputbytes() > 0U);
     assert(crypto_core_salsa20_inputbytes() > 0U);
     assert(crypto_core_salsa20_keybytes() > 0U);

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

@@ -45,6 +45,23 @@ main(void)
             printf("conversion failed\n");
         }
     }
+
+    sodium_hex2bin(ed25519_pk, crypto_sign_ed25519_PUBLICKEYBYTES,
+                   "0000000000000000000000000000000000000000000000000000000000000000"
+                   "0000000000000000000000000000000000000000000000000000000000000000",
+                   64, NULL, NULL, NULL);
+    assert(crypto_sign_ed25519_pk_to_curve25519(curve25519_pk, ed25519_pk) == -1);
+    sodium_hex2bin(ed25519_pk, crypto_sign_ed25519_PUBLICKEYBYTES,
+                   "0200000000000000000000000000000000000000000000000000000000000000"
+                   "0000000000000000000000000000000000000000000000000000000000000000",
+                   64, NULL, NULL, NULL);
+    assert(crypto_sign_ed25519_pk_to_curve25519(curve25519_pk, ed25519_pk) == -1);
+    sodium_hex2bin(ed25519_pk, crypto_sign_ed25519_PUBLICKEYBYTES,
+                   "0500000000000000000000000000000000000000000000000000000000000000"
+                   "0000000000000000000000000000000000000000000000000000000000000000",
+                   64, NULL, NULL, NULL);
+    assert(crypto_sign_ed25519_pk_to_curve25519(curve25519_pk, ed25519_pk) == -1);
+
     printf("ok\n");
 
     return 0;

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

@@ -19,8 +19,8 @@ tv_kdf(void)
     }
     subkey = (unsigned char *) sodium_malloc(crypto_kdf_BYTES_MAX);
     for (i = 0; i < 10; i++) {
-        assert(crypto_kdf_blake2b_derive_from_key(subkey, crypto_kdf_BYTES_MAX,
-                                                  i, context, master_key) == 0);
+        assert(crypto_kdf_derive_from_key(subkey, crypto_kdf_BYTES_MAX,
+                                          i, context, master_key) == 0);
         sodium_bin2hex(hex, sizeof hex, subkey, crypto_kdf_BYTES_MAX);
         printf("%s\n", hex);
     }
@@ -28,8 +28,8 @@ tv_kdf(void)
 
     for (i = 0; i < crypto_kdf_BYTES_MAX + 2; i++) {
         subkey = (unsigned char *) sodium_malloc(crypto_kdf_BYTES_MAX);
-        if (crypto_kdf_blake2b_derive_from_key(subkey, (size_t) i,
-                                               i, context, master_key) == 0) {
+        if (crypto_kdf_derive_from_key(subkey, (size_t) i,
+                                       i, context, master_key) == 0) {
             sodium_bin2hex(hex, sizeof hex, subkey, (size_t) i);
             printf("%s\n", hex);
         } else {
@@ -48,6 +48,10 @@ tv_kdf(void)
     assert(crypto_kdf_contextbytes() == crypto_kdf_CONTEXTBYTES);
     assert(crypto_kdf_KEYBYTES >= 16);
     assert(crypto_kdf_keybytes() == crypto_kdf_KEYBYTES);
+    assert(crypto_kdf_bytes_min() == crypto_kdf_blake2b_bytes_min());
+    assert(crypto_kdf_bytes_max() == crypto_kdf_blake2b_bytes_max());
+    assert(crypto_kdf_contextbytes() == crypto_kdf_blake2b_contextbytes());
+    assert(crypto_kdf_keybytes() == crypto_kdf_blake2b_keybytes());
 
     printf("tv_kdf: ok\n");
 }

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

@@ -23,8 +23,11 @@ tv_keygen(void)
         { crypto_onetimeauth_poly1305_keygen, crypto_onetimeauth_poly1305_KEYBYTES },
         { crypto_aead_chacha20poly1305_ietf_keygen, crypto_aead_chacha20poly1305_ietf_KEYBYTES },
         { crypto_aead_chacha20poly1305_keygen, crypto_aead_chacha20poly1305_KEYBYTES },
+        { crypto_aead_chacha20poly1305_ietf_keygen, crypto_aead_chacha20poly1305_ietf_KEYBYTES },
+        { crypto_aead_xchacha20poly1305_ietf_keygen, crypto_aead_xchacha20poly1305_ietf_KEYBYTES },
         { crypto_secretbox_xsalsa20poly1305_keygen, crypto_secretbox_xsalsa20poly1305_KEYBYTES },
         { crypto_secretbox_keygen, crypto_secretbox_KEYBYTES },
+        { crypto_secretstream_xchacha20poly1305_keygen, crypto_secretstream_xchacha20poly1305_KEYBYTES },
         { crypto_shorthash_keygen, crypto_shorthash_KEYBYTES },
         { crypto_stream_keygen, crypto_stream_KEYBYTES },
         { crypto_stream_chacha20_keygen, crypto_stream_chacha20_KEYBYTES },
@@ -34,7 +37,7 @@ tv_keygen(void)
     };
     const KeygenTV *tv;
     unsigned char  *key;
-    int             i;
+    size_t          i;
     int             j;
 
     for (i = 0; i < (sizeof tvs) / (sizeof tvs[0]); i++) {
@@ -49,7 +52,7 @@ tv_keygen(void)
         }
         sodium_free(key);
         if (j >= 10000) {
-            printf("Buffer underflow with test vector %d\n", i);
+            printf("Buffer underflow with test vector %u\n", (unsigned int) i);
         }
     }
     printf("tv_keygen: ok\n");

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

@@ -2,6 +2,12 @@
 #define TEST_NAME "kx"
 #include "cmptest.h"
 
+static const unsigned char small_order_p[crypto_scalarmult_BYTES] = {
+    0xe0, 0xeb, 0x7a, 0x7c, 0x3b, 0x41, 0xb8, 0xae, 0x16, 0x56, 0xe3,
+    0xfa, 0xf1, 0x9f, 0xc4, 0x6a, 0xda, 0x09, 0x8d, 0xeb, 0x9c, 0x32,
+    0xb1, 0xfd, 0x86, 0x62, 0x05, 0x16, 0x5f, 0x49, 0xb8, 0x00
+};
+
 static void
 tv_kx(void)
 {
@@ -33,6 +39,9 @@ tv_kx(void)
     client_rx = (unsigned char *) sodium_malloc(crypto_kx_SESSIONKEYBYTES);
     client_tx = (unsigned char *) sodium_malloc(crypto_kx_SESSIONKEYBYTES);
 
+    assert(crypto_kx_client_session_keys(client_rx, client_tx,
+                                         client_pk, client_sk,
+                                         small_order_p) == -1);
     if (crypto_kx_client_session_keys(client_rx, client_tx,
                                       client_pk, client_sk, server_pk) != 0) {
         printf("crypto_kx_client_session_keys() failed\n");
@@ -41,6 +50,9 @@ tv_kx(void)
     server_rx = (unsigned char *) sodium_malloc(crypto_kx_SESSIONKEYBYTES);
     server_tx = (unsigned char *) sodium_malloc(crypto_kx_SESSIONKEYBYTES);
 
+    assert(crypto_kx_server_session_keys(server_rx, server_tx,
+                                         server_pk, server_sk,
+                                         small_order_p) == -1);
     if (crypto_kx_server_session_keys(server_rx, server_tx,
                                       server_pk, server_sk, client_pk) != 0) {
         printf("crypto_kx_server_session_keys() failed\n");
@@ -91,6 +103,24 @@ tv_kx(void)
     sodium_bin2hex(hex, sizeof hex, client_tx, crypto_kx_SESSIONKEYBYTES);
     printf("client_tx: [%s]\n", hex);
 
+    randombytes_buf(client_rx, crypto_kx_SESSIONKEYBYTES);
+    randombytes_buf(client_tx, crypto_kx_SESSIONKEYBYTES);
+    randombytes_buf(server_rx, crypto_kx_SESSIONKEYBYTES);
+    randombytes_buf(server_tx, crypto_kx_SESSIONKEYBYTES);
+    if (crypto_kx_client_session_keys(client_rx, NULL,
+                                      client_pk, client_sk, server_pk) != 0 ||
+        crypto_kx_client_session_keys(NULL, client_tx,
+                                      client_pk, client_sk, server_pk) != 0 ||
+        crypto_kx_server_session_keys(server_rx, NULL,
+                                      server_pk, server_sk, client_pk) != 0 ||
+        crypto_kx_server_session_keys(NULL, server_tx,
+                                      server_pk, server_sk, client_pk) != 0) {
+        printf("failure when one of the pointers happens to be NULL");
+    }
+    assert(memcmp(client_rx, client_tx, crypto_kx_SESSIONKEYBYTES) == 0);
+    assert(memcmp(client_tx, server_rx, crypto_kx_SESSIONKEYBYTES) == 0);
+    assert(memcmp(server_rx, server_tx, crypto_kx_SESSIONKEYBYTES) == 0);
+
     sodium_free(client_rx);
     sodium_free(client_tx);
     sodium_free(server_rx);

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

@@ -0,0 +1,187 @@
+
+#define TEST_NAME "metamorphic"
+#include "cmptest.h"
+
+#define MAXLEN 512
+#define MAX_ITER 1000
+
+static void
+mm_generichash(void)
+{
+    crypto_generichash_state st;
+    unsigned char *h, *h2;
+    unsigned char *k;
+    unsigned char *m;
+    size_t         hlen;
+    size_t         klen;
+    size_t         mlen;
+    size_t         l1, l2;
+    int            i;
+
+    for (i = 0; i < MAX_ITER; i++) {
+        mlen = randombytes_uniform(MAXLEN);
+        m = (unsigned char *) sodium_malloc(mlen);
+        klen = randombytes_uniform(crypto_generichash_KEYBYTES_MAX -
+                                   crypto_generichash_KEYBYTES_MIN + 1U)
+            + crypto_generichash_KEYBYTES_MIN;
+        k = (unsigned char *) sodium_malloc(klen);
+        hlen = randombytes_uniform(crypto_generichash_BYTES_MAX -
+                                   crypto_generichash_BYTES_MIN + 1U)
+            + crypto_generichash_BYTES_MIN;
+        h = (unsigned char *) sodium_malloc(hlen);
+        h2 = (unsigned char *) sodium_malloc(hlen);
+
+        randombytes_buf(k, klen);
+        randombytes_buf(m, mlen);
+
+        crypto_generichash_init(&st, k, klen, hlen);
+        l1 = randombytes_uniform(mlen);
+        l2 = randombytes_uniform(mlen - l1);
+        crypto_generichash_update(&st, m, l1);
+        crypto_generichash_update(&st, m + l1, l2);
+        crypto_generichash_update(&st, m + l1 + l2, mlen - l1 - l2);
+        crypto_generichash_final(&st, h, hlen);
+
+        crypto_generichash(h2, hlen, m, mlen, k, klen);
+
+        assert(memcmp(h, h2, hlen) == 0);
+
+        sodium_free(h2);
+        sodium_free(h);
+        sodium_free(k);
+        sodium_free(m);
+    }
+}
+
+static void
+mm_onetimeauth(void)
+{
+    crypto_onetimeauth_state st;
+    unsigned char *h, *h2;
+    unsigned char *k;
+    unsigned char *m;
+    size_t         mlen;
+    size_t         l1, l2;
+    int            i;
+
+    for (i = 0; i < MAX_ITER; i++) {
+        mlen = randombytes_uniform(MAXLEN);
+        m = (unsigned char *) sodium_malloc(mlen);
+        k = (unsigned char *) sodium_malloc(crypto_onetimeauth_KEYBYTES);
+        h = (unsigned char *) sodium_malloc(crypto_onetimeauth_BYTES);
+        h2 = (unsigned char *) sodium_malloc(crypto_onetimeauth_BYTES);
+
+        crypto_onetimeauth_keygen(k);
+        randombytes_buf(m, mlen);
+
+        crypto_onetimeauth_init(&st, k);
+        l1 = randombytes_uniform(mlen);
+        l2 = randombytes_uniform(mlen - l1);
+        crypto_onetimeauth_update(&st, m, l1);
+        crypto_onetimeauth_update(&st, m + l1, l2);
+        crypto_onetimeauth_update(&st, m + l1 + l2, mlen - l1 - l2);
+        crypto_onetimeauth_final(&st, h);
+
+        crypto_onetimeauth(h2, m, mlen, k);
+
+        assert(memcmp(h, h2, crypto_onetimeauth_BYTES) == 0);
+
+        sodium_free(h2);
+        sodium_free(h);
+        sodium_free(k);
+        sodium_free(m);
+    }
+}
+
+static void
+mm_hmacsha256(void)
+{
+    crypto_auth_hmacsha256_state st;
+    unsigned char *h, *h2;
+    unsigned char *k;
+    unsigned char *m;
+    size_t         mlen;
+    size_t         l1, l2;
+    int            i;
+
+    for (i = 0; i < MAX_ITER; i++) {
+        mlen = randombytes_uniform(MAXLEN);
+        m = (unsigned char *) sodium_malloc(mlen);
+        k = (unsigned char *) sodium_malloc(crypto_auth_hmacsha256_KEYBYTES);
+        h = (unsigned char *) sodium_malloc(crypto_auth_hmacsha256_BYTES);
+        h2 = (unsigned char *) sodium_malloc(crypto_auth_hmacsha256_BYTES);
+
+        crypto_auth_hmacsha256_keygen(k);
+        randombytes_buf(m, mlen);
+
+        crypto_auth_hmacsha256_init(&st, k, crypto_auth_hmacsha256_KEYBYTES);
+        l1 = randombytes_uniform(mlen);
+        l2 = randombytes_uniform(mlen - l1);
+        crypto_auth_hmacsha256_update(&st, m, l1);
+        crypto_auth_hmacsha256_update(&st, m + l1, l2);
+        crypto_auth_hmacsha256_update(&st, m + l1 + l2, mlen - l1 - l2);
+        crypto_auth_hmacsha256_final(&st, h);
+
+        crypto_auth_hmacsha256(h2, m, mlen, k);
+
+        assert(memcmp(h, h2, crypto_auth_hmacsha256_BYTES) == 0);
+
+        sodium_free(h2);
+        sodium_free(h);
+        sodium_free(k);
+        sodium_free(m);
+    }
+}
+
+static void
+mm_hmacsha512(void)
+{
+    crypto_auth_hmacsha512_state st;
+    unsigned char *h, *h2;
+    unsigned char *k;
+    unsigned char *m;
+    size_t         mlen;
+    size_t         l1, l2;
+    int            i;
+
+    for (i = 0; i < MAX_ITER; i++) {
+        mlen = randombytes_uniform(MAXLEN);
+        m = (unsigned char *) sodium_malloc(mlen);
+        k = (unsigned char *) sodium_malloc(crypto_auth_hmacsha512_KEYBYTES);
+        h = (unsigned char *) sodium_malloc(crypto_auth_hmacsha512_BYTES);
+        h2 = (unsigned char *) sodium_malloc(crypto_auth_hmacsha512_BYTES);
+
+        crypto_auth_hmacsha512_keygen(k);
+        randombytes_buf(m, mlen);
+
+        crypto_auth_hmacsha512_init(&st, k, crypto_auth_hmacsha512_KEYBYTES);
+        l1 = randombytes_uniform(mlen);
+        l2 = randombytes_uniform(mlen - l1);
+        crypto_auth_hmacsha512_update(&st, m, l1);
+        crypto_auth_hmacsha512_update(&st, m + l1, l2);
+        crypto_auth_hmacsha512_update(&st, m + l1 + l2, mlen - l1 - l2);
+        crypto_auth_hmacsha512_final(&st, h);
+
+        crypto_auth_hmacsha512(h2, m, mlen, k);
+
+        assert(memcmp(h, h2, crypto_auth_hmacsha512_BYTES) == 0);
+
+        sodium_free(h2);
+        sodium_free(h);
+        sodium_free(k);
+        sodium_free(m);
+    }
+}
+
+int
+main(void)
+{
+    mm_generichash();
+    mm_onetimeauth();
+    mm_hmacsha256();
+    mm_hmacsha512();
+
+    printf("OK\n");
+
+    return 0;
+}

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

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