rbnacl-libsodium 1.0.0 → 1.0.1

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

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

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

@@ -2,43 +2,51 @@
 #define TEST_NAME "generichash"
 #include "cmptest.h"
 
+#define MAXLEN 64
+
 int main(void)
 {
-#define MAXLEN 64
-    unsigned char in[MAXLEN], out[crypto_generichash_BYTES_MAX],
-        k[crypto_generichash_KEYBYTES_MAX];
-    size_t h, i, j;
+    unsigned char in[MAXLEN];
+    unsigned char out[crypto_generichash_BYTES_MAX];
+    unsigned char k[crypto_generichash_KEYBYTES_MAX];
+    size_t        h;
+    size_t        i;
+    size_t        j;
 
-    for (h = 0; h < crypto_generichash_KEYBYTES_MAX; ++h)
-        k[h] = h;
+    for (h = 0; h < crypto_generichash_KEYBYTES_MAX; ++h) {
+        k[h] = (unsigned char) h;
+    }
 
     for (i = 0; i < MAXLEN; ++i) {
-        in[i] = i;
-        crypto_generichash(out, 1 + i % crypto_generichash_BYTES_MAX, in, i, k,
+        in[i] = (unsigned char) i;
+        crypto_generichash(out, 1 + i % crypto_generichash_BYTES_MAX, in,
+                           (unsigned long long) i, k,
                            1 + i % crypto_generichash_KEYBYTES_MAX);
         for (j = 0; j < 1 + i % crypto_generichash_BYTES_MAX; ++j) {
-            printf("%02x", (unsigned int)out[j]);
+            printf("%02x", (unsigned int) out[j]);
         }
         printf("\n");
     }
 
     memset(out, 0, sizeof out);
-    crypto_generichash(out, crypto_generichash_BYTES_MAX, in, i, k, 0U);
+    crypto_generichash(out, crypto_generichash_BYTES_MAX, in,
+                       (unsigned long long) i, k, 0U);
     for (j = 0; j < crypto_generichash_BYTES_MAX; ++j) {
-        printf("%02x", (unsigned int)out[j]);
+        printf("%02x", (unsigned int) out[j]);
     }
     printf("\n");
 
     memset(out, 0, sizeof out);
-    crypto_generichash(out, crypto_generichash_BYTES_MAX, in, i, NULL, 1U);
+    crypto_generichash(out, crypto_generichash_BYTES_MAX, in,
+                       (unsigned long long) i, NULL, 1U);
     for (j = 0; j < crypto_generichash_BYTES_MAX; ++j) {
-        printf("%02x", (unsigned int)out[j]);
+        printf("%02x", (unsigned int) out[j]);
     }
     printf("\n");
 
     assert(crypto_generichash(out, 0U, in, sizeof in, k, sizeof k) == -1);
-    assert(crypto_generichash(out, crypto_generichash_BYTES_MAX + 1U, in, sizeof in,
-                              k, sizeof k) == -1);
+    assert(crypto_generichash(out, crypto_generichash_BYTES_MAX + 1U,
+                              in, sizeof in, k, sizeof k) == -1);
     assert(crypto_generichash(out, sizeof out, in, sizeof in,
                               k, crypto_generichash_KEYBYTES_MAX + 1U) == -1);
 

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

@@ -12,23 +12,27 @@ int main(void)
     unsigned char personal[crypto_generichash_blake2b_PERSONALBYTES]
         = { '5', '1', '2', '6', 'f', 'b', '2', 'a',
             '3', '7', '4', '0', '0', 'd', '2', 'a' };
-    unsigned char in[MAXLEN], out[crypto_generichash_blake2b_BYTES_MAX],
-        k[crypto_generichash_blake2b_KEYBYTES_MAX];
-    size_t h, i, j;
-
-    for (h = 0; h < crypto_generichash_blake2b_KEYBYTES_MAX; ++h)
-        k[h] = h;
+    unsigned char in[MAXLEN];
+    unsigned char out[crypto_generichash_blake2b_BYTES_MAX];
+    unsigned char k[crypto_generichash_blake2b_KEYBYTES_MAX];
+    size_t        h;
+    size_t        i;
+    size_t        j;
+
+    for (h = 0; h < crypto_generichash_blake2b_KEYBYTES_MAX; ++h) {
+        k[h] = (unsigned char) h;
+    }
 
     for (i = 0; i < MAXLEN; ++i) {
-        in[i] = i;
+        in[i] = (unsigned char) i;
         crypto_generichash_blake2b_init_salt_personal(
             &st, k, 1 + i % crypto_generichash_blake2b_KEYBYTES_MAX,
             1 + i % crypto_generichash_blake2b_BYTES_MAX, salt, personal);
-        crypto_generichash_blake2b_update(&st, in, i);
+        crypto_generichash_blake2b_update(&st, in, (unsigned long long) i);
         crypto_generichash_blake2b_final(
             &st, out, 1 + i % crypto_generichash_blake2b_BYTES_MAX);
         for (j = 0; j < 1 + i % crypto_generichash_blake2b_BYTES_MAX; ++j) {
-            printf("%02x", (unsigned int)out[j]);
+            printf("%02x", (unsigned int) out[j]);
         }
         printf("\n");
     }
@@ -40,7 +44,7 @@ int main(void)
     crypto_generichash_blake2b_final(&st, out,
                                      crypto_generichash_blake2b_BYTES_MAX);
     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
-        printf("%02x", (unsigned int)out[j]);
+        printf("%02x", (unsigned int) out[j]);
     }
     printf("\n");
 
@@ -51,7 +55,7 @@ int main(void)
     crypto_generichash_blake2b_final(&st, out,
                                      crypto_generichash_blake2b_BYTES_MAX);
     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
-        printf("%02x", (unsigned int)out[j]);
+        printf("%02x", (unsigned int) out[j]);
     }
     printf("\n");
 
@@ -63,7 +67,7 @@ int main(void)
     crypto_generichash_blake2b_final(&st, out,
                                      crypto_generichash_blake2b_BYTES_MAX);
     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
-        printf("%02x", (unsigned int)out[j]);
+        printf("%02x", (unsigned int) out[j]);
     }
     printf("\n");
 
@@ -77,7 +81,7 @@ int main(void)
     crypto_generichash_blake2b_final(
         &st, out, crypto_generichash_blake2b_BYTES_MAX);
     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
-        printf("%02x", (unsigned int)out[j]);
+        printf("%02x", (unsigned int) out[j]);
     }
     printf("\n");
 
@@ -86,7 +90,7 @@ int main(void)
         out, crypto_generichash_blake2b_BYTES_MAX, in, MAXLEN,
         k, 0U, salt, personal);
     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
-        printf("%02x", (unsigned int)out[j]);
+        printf("%02x", (unsigned int) out[j]);
     }
     printf("\n");
 
@@ -95,7 +99,7 @@ int main(void)
         out, crypto_generichash_blake2b_BYTES_MAX, in, MAXLEN,
         NULL, crypto_generichash_blake2b_KEYBYTES_MAX, salt, personal);
     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
-        printf("%02x", (unsigned int)out[j]);
+        printf("%02x", (unsigned int) out[j]);
     }
     printf("\n");
 
@@ -104,7 +108,7 @@ int main(void)
         out, crypto_generichash_blake2b_BYTES_MAX, in, MAXLEN,
         k, crypto_generichash_blake2b_KEYBYTES_MAX, salt, personal);
     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
-        printf("%02x", (unsigned int)out[j]);
+        printf("%02x", (unsigned int) out[j]);
     }
     printf("\n");
 
@@ -113,7 +117,7 @@ int main(void)
         out, crypto_generichash_blake2b_BYTES_MAX, in, MAXLEN,
         k, crypto_generichash_blake2b_KEYBYTES_MAX, NULL, personal);
     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
-        printf("%02x", (unsigned int)out[j]);
+        printf("%02x", (unsigned int) out[j]);
     }
     printf("\n");
 
@@ -122,7 +126,7 @@ int main(void)
         out, crypto_generichash_blake2b_BYTES_MAX, in, MAXLEN,
         k, crypto_generichash_blake2b_KEYBYTES_MAX, salt, NULL);
     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
-        printf("%02x", (unsigned int)out[j]);
+        printf("%02x", (unsigned int) out[j]);
     }
     printf("\n");
 
@@ -131,7 +135,7 @@ int main(void)
     crypto_generichash_blake2b_update(&st, in, MAXLEN);
     crypto_generichash_blake2b_final(&st, out, crypto_generichash_blake2b_BYTES_MAX);
     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
-        printf("%02x", (unsigned int)out[j]);
+        printf("%02x", (unsigned int) out[j]);
     }
     printf("\n");
 
@@ -140,7 +144,7 @@ int main(void)
     crypto_generichash_blake2b_update(&st, in, MAXLEN);
     crypto_generichash_blake2b_final(&st, out, crypto_generichash_blake2b_BYTES_MAX);
     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
-        printf("%02x", (unsigned int)out[j]);
+        printf("%02x", (unsigned int) out[j]);
     }
     printf("\n");
 

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

@@ -5,12 +5,12 @@
 static void tv(void)
 {
     static struct {
-        const char *passwd_hex;
-        unsigned long long passwdlen;
-        const char *salt_hex;
-        unsigned long long outlen;
-        unsigned long long opslimit;
-        size_t memlimit;
+        const char         *passwd_hex;
+        size_t              passwdlen;
+        const char         *salt_hex;
+        size_t              outlen;
+        unsigned long long  opslimit;
+        size_t              memlimit;
     } tests[] = {
           { "a347ae92bce9f80f6f595a4480fc9c2fe7e7d7148d371e9487d75f5c23008ffae0"
             "65577a928febd9b1973a5a95073acdbeb6a030cfc0d79caa2dc5cd011cef02c08d"
@@ -85,21 +85,22 @@ static void tv(void)
             "3d968b2752b8838431165059319f3ff8910b7b8ecb54ea01d3f54769e9d98daf",
             167, 717248, 10784179 },
       };
-    char passwd[256];
+    char          passwd[256];
     unsigned char salt[crypto_pwhash_scryptsalsa208sha256_SALTBYTES];
     unsigned char out[256];
-    char out_hex[256 * 2 + 1];
-    size_t i = 0U;
+    char          out_hex[256 * 2 + 1];
+    size_t        i = 0U;
 
     do {
-        sodium_hex2bin((unsigned char *)passwd, sizeof passwd,
+        sodium_hex2bin((unsigned char *) passwd, sizeof passwd,
                        tests[i].passwd_hex, strlen(tests[i].passwd_hex), NULL,
                        NULL, NULL);
         sodium_hex2bin(salt, sizeof salt, tests[i].salt_hex,
                        strlen(tests[i].salt_hex), NULL, NULL, NULL);
         if (crypto_pwhash_scryptsalsa208sha256(
-                out, tests[i].outlen, passwd, tests[i].passwdlen,
-                (const unsigned char *)salt, tests[i].opslimit,
+                out, (unsigned long long) tests[i].outlen,
+                passwd, tests[i].passwdlen,
+                (const unsigned char *) salt, tests[i].opslimit,
                 tests[i].memlimit) != 0) {
             printf("pwhash failure\n");
         }
@@ -111,12 +112,12 @@ static void tv(void)
 static void tv2(void)
 {
     static struct {
-        const char *passwd_hex;
-        unsigned long long passwdlen;
-        const char *salt_hex;
-        unsigned long long outlen;
-        unsigned long long opslimit;
-        size_t memlimit;
+        const char         *passwd_hex;
+        size_t              passwdlen;
+        const char         *salt_hex;
+        size_t              outlen;
+        unsigned long long  opslimit;
+        size_t              memlimit;
     } tests[] = {
           { "a347ae92bce9f80f6f595a4480fc9c2fe7e7d7148d371e9487d75f5c23008ffae0"
             "65577a928febd9b1973a5a95073acdbeb6a030cfc0d79caa2dc5cd011cef02c08d"
@@ -133,11 +134,11 @@ static void tv2(void)
             "5541fbc995d5c197ba290346d2c559dedf405cf97e5f95482143202f9e74f5c2",
             155, 32768, 1397645 },
       };
-    char passwd[256];
+    char          passwd[256];
     unsigned char salt[crypto_pwhash_scryptsalsa208sha256_SALTBYTES];
     unsigned char out[256];
-    char out_hex[256 * 2 + 1];
-    size_t i = 0U;
+    char          out_hex[256 * 2 + 1];
+    size_t        i = 0U;
 
     do {
         sodium_hex2bin((unsigned char *)passwd, sizeof passwd,
@@ -146,8 +147,9 @@ static void tv2(void)
         sodium_hex2bin(salt, sizeof salt, tests[i].salt_hex,
                        strlen(tests[i].salt_hex), NULL, NULL, NULL);
         if (crypto_pwhash_scryptsalsa208sha256(
-                out, tests[i].outlen, passwd, tests[i].passwdlen,
-                (const unsigned char *)salt, tests[i].opslimit,
+                out, (unsigned long long) tests[i].outlen,
+                passwd, tests[i].passwdlen,
+                (const unsigned char *) salt, tests[i].opslimit,
                 tests[i].memlimit) != 0) {
             printf("pwhash failure\n");
         }
@@ -283,13 +285,10 @@ static void tv3(void)
 
 int main(void)
 {
-    char str_out[crypto_pwhash_scryptsalsa208sha256_STRBYTES];
-    char str_out2[crypto_pwhash_scryptsalsa208sha256_STRBYTES];
-    unsigned char out[OUT_LEN];
-    char out_hex[OUT_LEN * 2 + 1];
+    char        str_out[crypto_pwhash_scryptsalsa208sha256_STRBYTES];
+    char        str_out2[crypto_pwhash_scryptsalsa208sha256_STRBYTES];
     const char *salt = "[<~A 32-bytes salt for scrypt~>]";
     const char *passwd = "Correct Horse Battery Staple";
-    size_t i;
 
     tv();
     tv2();

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

@@ -2,12 +2,12 @@
 #define TEST_NAME "scalarmult6"
 #include "cmptest.h"
 
-unsigned char bobsk[32]
+unsigned char bobsk_[crypto_scalarmult_SCALARBYTES]
     = { 0x5d, 0xab, 0x08, 0x7e, 0x62, 0x4a, 0x8a, 0x4b, 0x79, 0xe1, 0x7f,
         0x8b, 0x83, 0x80, 0x0e, 0xe6, 0x6f, 0x3b, 0xb1, 0x29, 0x26, 0x18,
         0xb6, 0xfd, 0x1c, 0x2f, 0x8b, 0x27, 0xff, 0x88, 0xe0, 0xeb };
 
-unsigned char alicepk[32]
+unsigned char alicepk_[crypto_scalarmult_SCALARBYTES]
     = { 0x85, 0x20, 0xf0, 0x09, 0x89, 0x30, 0xa7, 0x54, 0x74, 0x8b, 0x7d,
         0xdc, 0xb4, 0x3e, 0xf7, 0x5a, 0x0d, 0xbf, 0x3a, 0x0d, 0x26, 0x38,
         0x1a, 0xf4, 0xeb, 0xa4, 0xa9, 0x8e, 0xaa, 0x9b, 0x4e, 0x6a };
@@ -16,10 +16,24 @@ unsigned char k[32];
 
 int main(void)
 {
-    int i;
+    unsigned char *k;
+    unsigned char *bobsk;
+    unsigned char *alicepk;
+    int            i;
+
+    k = (unsigned char *) sodium_malloc(crypto_scalarmult_BYTES);
+    bobsk = (unsigned char *) sodium_malloc(crypto_scalarmult_SCALARBYTES);
+    alicepk = (unsigned char *) sodium_malloc(crypto_scalarmult_SCALARBYTES);
+    assert(k != NULL && bobsk != NULL && alicepk != NULL);
+
+    memcpy(bobsk, bobsk_, crypto_scalarmult_SCALARBYTES);
+    memcpy(alicepk, alicepk_, crypto_scalarmult_SCALARBYTES);
 
     crypto_scalarmult(k, bobsk, alicepk);
 
+    sodium_free(alicepk);
+    sodium_free(bobsk);
+
     for (i = 0; i < 32; ++i) {
         if (i > 0) {
             printf(",");
@@ -31,5 +45,7 @@ int main(void)
             printf("\n");
         }
     }
+    sodium_free(k);
+
     return 0;
 }

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

@@ -11,27 +11,43 @@ unsigned char mac[crypto_secretbox_MACBYTES];
 
 int main(void)
 {
-    unsigned long long mlen;
-    unsigned long long i;
+    size_t mlen;
+    size_t i;
 
     randombytes_buf(k, sizeof k);
-    mlen = (unsigned long long)randombytes_uniform((uint32_t)sizeof m);
-    randombytes_buf(m, mlen);
+    mlen = (size_t) randombytes_uniform((uint32_t) sizeof m);
+    randombytes_buf(m, (unsigned long long) mlen);
     randombytes_buf(nonce, sizeof nonce);
-    crypto_secretbox_easy(c, m, mlen, nonce, k);
-    crypto_secretbox_open_easy(m2, c, mlen + crypto_secretbox_MACBYTES, nonce,
-                               k);
+    crypto_secretbox_easy(c, m, (unsigned long long) mlen, nonce, k);
+    crypto_secretbox_open_easy(m2, c,
+                               (unsigned long long) mlen + crypto_secretbox_MACBYTES,
+                               nonce, k);
     printf("%d\n", memcmp(m, m2, mlen));
 
     for (i = 0; i < mlen + crypto_secretbox_MACBYTES - 1; i++) {
-        if (crypto_secretbox_open_easy(m2, c, i, nonce, k) == 0) {
-            printf("short open() should have failed");
+        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, mlen, nonce, k);
-    crypto_secretbox_open_detached(m2, c, mac, mlen, nonce, k);
+    crypto_secretbox_detached(c, mac, m, (unsigned long long) mlen, nonce, k);
+    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));
+
     return 0;
 }

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

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

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

@@ -2,21 +2,26 @@
 #define TEST_NAME "shorthash"
 #include "cmptest.h"
 
+#define MAXLEN 64
+
 int main(void)
 {
-#define MAXLEN 64
-    unsigned char in[MAXLEN], out[crypto_shorthash_BYTES],
-        k[crypto_shorthash_KEYBYTES];
-    size_t i, j;
+    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] = i;
+    for (i = 0; i < crypto_shorthash_KEYBYTES; ++i) {
+        k[i] = (unsigned char) i;
+    }
 
     for (i = 0; i < MAXLEN; ++i) {
-        in[i] = i;
-        crypto_shorthash(out, in, i, k);
-        for (j = 0; j < crypto_shorthash_BYTES; ++j)
-            printf("%02x", (unsigned int)out[j]);
+        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);