rbnacl-libsodium 0.7.0 → 1.0.0

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

@@ -1,6 +1,3 @@
-#include <stdio.h>
-
-#include "crypto_uint8.h"
 
 #define TEST_NAME "generichash"
 #include "cmptest.h"
@@ -8,20 +5,67 @@
 int main(void)
 {
 #define MAXLEN 64
-    crypto_uint8 in[MAXLEN], out[crypto_generichash_BYTES_MAX], k[crypto_generichash_KEYBYTES_MAX];
-    size_t h,i,j;
-
-    for(h = 0; h < crypto_generichash_KEYBYTES_MAX; ++h) k[h] = h;
-
-    for(i = 0; i < MAXLEN; ++i) {
-        in[i]=i;
-        crypto_generichash(out, 1 + i % crypto_generichash_BYTES_MAX,
-                           in, 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]);
+    unsigned char in[MAXLEN], out[crypto_generichash_BYTES_MAX],
+        k[crypto_generichash_KEYBYTES_MAX];
+    size_t h, i, j;
+
+    for (h = 0; h < crypto_generichash_KEYBYTES_MAX; ++h)
+        k[h] = h;
+
+    for (i = 0; i < MAXLEN; ++i) {
+        in[i] = i;
+        crypto_generichash(out, 1 + i % crypto_generichash_BYTES_MAX, in, 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("\n");
     }
+
+    memset(out, 0, sizeof out);
+    crypto_generichash(out, crypto_generichash_BYTES_MAX, in, i, k, 0U);
+    for (j = 0; j < crypto_generichash_BYTES_MAX; ++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);
+    for (j = 0; j < crypto_generichash_BYTES_MAX; ++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, sizeof out, in, sizeof in,
+                              k, crypto_generichash_KEYBYTES_MAX + 1U) == -1);
+
+    assert(crypto_generichash_bytes_min() > 0U);
+    assert(crypto_generichash_bytes_max() > 0U);
+    assert(crypto_generichash_bytes() > 0U);
+    assert(crypto_generichash_bytes() >= crypto_generichash_bytes_min());
+    assert(crypto_generichash_bytes() <= crypto_generichash_bytes_max());
+    assert(crypto_generichash_keybytes_min() > 0U);
+    assert(crypto_generichash_keybytes_max() > 0U);
+    assert(crypto_generichash_keybytes() > 0U);
+    assert(crypto_generichash_keybytes() >= crypto_generichash_keybytes_min());
+    assert(crypto_generichash_keybytes() <= crypto_generichash_keybytes_max());
+    assert(strcmp(crypto_generichash_primitive(), "blake2b") == 0);
+    assert(crypto_generichash_bytes_min()
+           == crypto_generichash_blake2b_bytes_min());
+    assert(crypto_generichash_bytes_max()
+           == crypto_generichash_blake2b_bytes_max());
+    assert(crypto_generichash_bytes() == crypto_generichash_blake2b_bytes());
+    assert(crypto_generichash_keybytes_min()
+           == crypto_generichash_blake2b_keybytes_min());
+    assert(crypto_generichash_keybytes_max()
+           == crypto_generichash_blake2b_keybytes_max());
+    assert(crypto_generichash_keybytes()
+           == crypto_generichash_blake2b_keybytes());
+    assert(crypto_generichash_blake2b_saltbytes() > 0U);
+    assert(crypto_generichash_blake2b_personalbytes() > 0U);
+
     return 0;
 }

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

@@ -62,3 +62,5 @@ cc66a891768e95a2717b040c111996f14942f10f2475c33aa5f1c97476e6f8386733d6b21c16102d
 9ff11c233aaf5e0242b0dbe6e110a42e58b86141ad0ef130fd2bb895700019782de66d435bf0a8d6f5eda5d7d1105e7a6f3ef17a9da8f9c16fc21075431a
 bdd3d0fafe8ba2b29d1ac0b79aa46e249cc9d3a82d0f772d690637bbdd353722356658d00436ff5dd5239ab747979329345eb8c7ed11b7331456ae87350fcf
 bd965bf31e87d70327536f2a341cebc4768eca275fa05ef98f7f1b71a0351298de006fba73fe6733ed01d75801b4a928e54231b38e38c562b2e33ea1284992fa
+2fc6e69fa26a89a5ed269092cb9b2a449a4409a7a44011eecad13d7c4b0456602d402fa5844f1a7a758136ce3d5d8d0e8b86921ffff4f692dd95bdc8e5ff0052
+2fc6e69fa26a89a5ed269092cb9b2a449a4409a7a44011eecad13d7c4b0456602d402fa5844f1a7a758136ce3d5d8d0e8b86921ffff4f692dd95bdc8e5ff0052

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

@@ -1,6 +1,3 @@
-#include <stdio.h>
-
-#include "crypto_uint8.h"
 
 #define TEST_NAME "generichash2"
 #include "cmptest.h"
@@ -9,23 +6,43 @@ int main(void)
 {
 #define MAXLEN 64
     crypto_generichash_state st;
-    crypto_uint8 in[MAXLEN], out[crypto_generichash_BYTES_MAX], k[crypto_generichash_KEYBYTES_MAX];
-    size_t h,i,j;
+    unsigned char in[MAXLEN], out[crypto_generichash_BYTES_MAX],
+        k[crypto_generichash_KEYBYTES_MAX];
+    size_t h, i, j;
 
-    for(h = 0; h < crypto_generichash_KEYBYTES_MAX; ++h) k[h] = h;
+    for (h = 0; h < crypto_generichash_KEYBYTES_MAX; ++h)
+        k[h] = h;
 
-    for(i = 0; i < MAXLEN; ++i) {
-        in[i]=i;
-        crypto_generichash_init(&st, k, 1 + i % crypto_generichash_KEYBYTES_MAX,
-                                1 + i % crypto_generichash_BYTES_MAX);
+    for (i = 0; i < MAXLEN; ++i) {
+        in[i] = i;
+        if (crypto_generichash_init(&st, k,
+                                    1 + i % crypto_generichash_KEYBYTES_MAX,
+                                    1 + i % crypto_generichash_BYTES_MAX) != 0) {
+            printf("crypto_generichash_init()\n");
+            return 1;
+        }
         crypto_generichash_update(&st, in, i);
         crypto_generichash_update(&st, in, i);
         crypto_generichash_update(&st, in, i);
-        crypto_generichash_final(&st, out, 1 + i % crypto_generichash_BYTES_MAX);
-        for (j = 0;j < 1 + i % crypto_generichash_BYTES_MAX;++j) {
-            printf("%02x",(unsigned int) out[j]);
+        crypto_generichash_final(&st, out,
+                                 1 + i % crypto_generichash_BYTES_MAX);
+        for (j = 0; j < 1 + i % crypto_generichash_BYTES_MAX; ++j) {
+            printf("%02x", (unsigned int)out[j]);
         }
         printf("\n");
     }
+
+    assert(crypto_generichash_init(&st, k, sizeof k, 0U) == -1);
+    assert(crypto_generichash_init(&st, k, sizeof k,
+                                   crypto_generichash_BYTES_MAX + 1U) == -1);
+    assert(crypto_generichash_init(&st, k, crypto_generichash_KEYBYTES_MAX + 1U,
+                                   sizeof out) == -1);
+    assert(crypto_generichash_init(&st, k, 0U, sizeof out) == 0);
+    assert(crypto_generichash_init(&st, k, 1U, sizeof out) == 0);
+    assert(crypto_generichash_init(&st, NULL, 1U, 0U) == -1);
+    assert(crypto_generichash_init(&st, NULL, crypto_generichash_KEYBYTES,
+                                   1U) == 0);
+    assert(crypto_generichash_init(&st, NULL, crypto_generichash_KEYBYTES,
+                                   0U) == -1);
     return 0;
 }

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

@@ -1,6 +1,3 @@
-#include <stdio.h>
-
-#include "crypto_uint8.h"
 
 #define TEST_NAME "generichash3"
 #include "cmptest.h"
@@ -9,28 +6,165 @@ int main(void)
 {
 #define MAXLEN 64
     crypto_generichash_blake2b_state st;
-    crypto_uint8 salt[crypto_generichash_blake2b_SALTBYTES] = {
-        '5', 'b', '6', 'b', '4', '1', 'e', 'd', '9', 'b', '3', '4', '3', 'f', 'e', '0'
-    };
-    crypto_uint8 personal[crypto_generichash_blake2b_PERSONALBYTES] = {
-        '5', '1', '2', '6', 'f', 'b', '2', 'a', '3', '7', '4', '0', '0', 'd', '2', 'a'
-    };    
-    crypto_uint8 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;
-
-    for(i = 0; i < MAXLEN; ++i) {
-        in[i]=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);
+    unsigned char salt[crypto_generichash_blake2b_SALTBYTES]
+        = { '5', 'b', '6', 'b', '4', '1', 'e', 'd',
+            '9', 'b', '3', '4', '3', 'f', 'e', '0' };
+    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;
+
+    for (i = 0; i < MAXLEN; ++i) {
+        in[i] = 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_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]);
+        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("\n");
     }
+
+    memset(out, 0, sizeof out);
+    crypto_generichash_blake2b_init_salt_personal(
+        &st, k, 0U, crypto_generichash_blake2b_BYTES_MAX, salt, personal);
+    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("\n");
+
+    memset(out, 0, sizeof out);
+    crypto_generichash_blake2b_init_salt_personal(
+        &st, NULL, 1U, crypto_generichash_blake2b_BYTES_MAX, salt, personal);
+    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("\n");
+
+    memset(out, 0, sizeof out);
+    crypto_generichash_blake2b_init_salt_personal(
+        &st, k, crypto_generichash_blake2b_KEYBYTES_MAX,
+    crypto_generichash_blake2b_BYTES_MAX, NULL, personal);
+    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("\n");
+
+    memset(out, 0, sizeof out);
+    crypto_generichash_blake2b_init_salt_personal(
+        &st, k, crypto_generichash_blake2b_KEYBYTES_MAX,
+        crypto_generichash_blake2b_BYTES_MAX, salt, NULL);
+    crypto_generichash_blake2b_update(&st, in, MAXLEN);
+    assert(crypto_generichash_blake2b_final(
+        &st, out, crypto_generichash_blake2b_BYTES_MAX + 1U) == -1);
+    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("\n");
+
+    memset(out, 0, sizeof out);
+    crypto_generichash_blake2b_salt_personal(
+        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("\n");
+
+    memset(out, 0, sizeof out);
+    crypto_generichash_blake2b_salt_personal(
+        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("\n");
+
+    memset(out, 0, sizeof out);
+    crypto_generichash_blake2b_salt_personal(
+        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("\n");
+
+    memset(out, 0, sizeof out);
+    crypto_generichash_blake2b_salt_personal(
+        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("\n");
+
+    memset(out, 0, sizeof out);
+    crypto_generichash_blake2b_salt_personal(
+        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("\n");
+
+    crypto_generichash_blake2b_init_salt_personal(&st, NULL, 0U, crypto_generichash_BYTES,
+                                                  NULL, personal);
+    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("\n");
+
+    crypto_generichash_blake2b_init_salt_personal(&st, NULL, 0U, crypto_generichash_BYTES,
+                                                  salt, NULL);
+    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("\n");
+
+    assert(crypto_generichash_blake2b_init_salt_personal(&st, k, sizeof k, 0U,
+                                                         salt, personal) == -1);
+    assert(crypto_generichash_blake2b_init_salt_personal(&st, k, sizeof k,
+                                                         crypto_generichash_BYTES_MAX + 1U,
+                                                         salt, personal) == -1);
+    assert(crypto_generichash_blake2b_init_salt_personal(&st, k,
+                                                         crypto_generichash_KEYBYTES_MAX + 1U,
+                                                         sizeof out, salt, personal) == -1);
+
+    assert(crypto_generichash_blake2b_salt_personal(out, 0U, in, MAXLEN,
+                                                    k, sizeof k,
+                                                    salt, personal) == -1);
+    assert(crypto_generichash_blake2b_salt_personal(out, crypto_generichash_BYTES_MAX + 1U,
+                                                    in, MAXLEN, k, sizeof k,
+                                                    salt, personal) == -1);
+    assert(crypto_generichash_blake2b_salt_personal(out, sizeof out, in, MAXLEN,
+                                                    k, crypto_generichash_KEYBYTES_MAX + 1U,
+                                                    salt, personal) == -1);
+    assert(crypto_generichash_blake2b_init_salt_personal(&st, k, sizeof k, crypto_generichash_BYTES,
+                                                         NULL, personal) == 0);
+    assert(crypto_generichash_blake2b_init_salt_personal(&st, k, sizeof k, crypto_generichash_BYTES,
+                                                         salt, NULL) == 0);
     return 0;
 }

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

@@ -62,3 +62,14 @@ c6d6722a916651a8671383d8260873347d9c248696b4cb3dac4dea9ba57ed971127cb18e44211d7e
 5dd258a3e7505bc6b9776b0df25676a1c19e2c8258c7b5f2e361423523d96299eb6827bc7c27e7bca2d2b59d717c2ebcb05e6dcaa32289d96fae9a4077ef
 19c14de35fe19c92cc0e624280e4136355d4cfa9a0a98b090c4b06f5665021920725852ff1f566b0c8c37157b25fb9f947a2e70b40577a17860a0732c170ac
 5fcdcc02be7714a0dbc77df498bf999ea9225d564adca1c121c9af03af92cac8177b9b4a86bcc47c79aa32aac58a3fef967b2132e9352d4613fe890beed2571b
+1afc8ec818bef0a479d2b4cac81d40a52cafa27f6d80c42fc23cbaf4141882ab59ab1101922fcb6e707ef2f61efd07cce5d09094e6bee420b1b96998c7cee96d
+1afc8ec818bef0a479d2b4cac81d40a52cafa27f6d80c42fc23cbaf4141882ab59ab1101922fcb6e707ef2f61efd07cce5d09094e6bee420b1b96998c7cee96d
+5789f474edd5206ededaccfc35e7dd3ed730748125b5395abf802b2601126b19b109a1db67556945bc79bb25e1ab59610599d155070e0e04354f11a6a5d6f3ac
+e78efc663a5547c089f2b3b08973c974c4bfd365eac18b80c68bdb3b1ba4554b54d6b8465a68a3b9aa0bc020621f16efd5b8dd8c7c01ed9ee3ec5544aae465ff
+1afc8ec818bef0a479d2b4cac81d40a52cafa27f6d80c42fc23cbaf4141882ab59ab1101922fcb6e707ef2f61efd07cce5d09094e6bee420b1b96998c7cee96d
+1afc8ec818bef0a479d2b4cac81d40a52cafa27f6d80c42fc23cbaf4141882ab59ab1101922fcb6e707ef2f61efd07cce5d09094e6bee420b1b96998c7cee96d
+fb4e2ad6b7fe6afd2ba06d5c1d79379c5bf10e336a35c89a1aaf408a805171716e0635a5b1d18190131e15b6888510bcb3e3752b050f892a09dbbde60b051495
+5789f474edd5206ededaccfc35e7dd3ed730748125b5395abf802b2601126b19b109a1db67556945bc79bb25e1ab59610599d155070e0e04354f11a6a5d6f3ac
+e78efc663a5547c089f2b3b08973c974c4bfd365eac18b80c68bdb3b1ba4554b54d6b8465a68a3b9aa0bc020621f16efd5b8dd8c7c01ed9ee3ec5544aae465ff
+4f9875a42ba0da8ae3448d2d62b1ff51be672eb1b8a1b0fa5bcd5334c861eff06b5903d672d318fd04e0ef94ddd37eca6d4ad2051a36a0236dc4cc09a5a44358
+ec9f272db92d1fa99324115f34cda8b4690ad029c1df36986cf9e1f844d8fdeca8e8e8311620ad24cbbfa12eccb676b979565405c8e2e20a2e4f18fb27c93d76

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

@@ -1,16 +1,41 @@
-#include <stdio.h>
 
 #define TEST_NAME "hash"
 #include "cmptest.h"
 
 unsigned char x[] = "testing\n";
+unsigned char x2[] = "The Conscience of a Hacker is a small essay written January 8, 1986 by a computer security hacker who went by the handle of The Mentor, who belonged to the 2nd generation of Legion of Doom.";
 unsigned char h[crypto_hash_BYTES];
 
 int main(void)
 {
-  size_t i;
-  crypto_hash(h,x,sizeof x - 1U);
-  for (i = 0;i < crypto_hash_BYTES;++i) printf("%02x",(unsigned int) h[i]);
-  printf("\n");
-  return 0;
+    size_t i;
+
+    crypto_hash(h, x, sizeof x - 1U);
+    for (i = 0; i < crypto_hash_BYTES; ++i) {
+        printf("%02x", (unsigned int)h[i]);
+    }
+    printf("\n");
+    crypto_hash(h, x2, sizeof x2 - 1U);
+    for (i = 0; i < crypto_hash_BYTES; ++i) {
+        printf("%02x", (unsigned int)h[i]);
+    }
+    printf("\n");
+    crypto_hash_sha256(h, x, sizeof x - 1U);
+    for (i = 0; i < crypto_hash_sha256_BYTES; ++i) {
+        printf("%02x", (unsigned int)h[i]);
+    }
+    printf("\n");
+    crypto_hash_sha256(h, x2, sizeof x2 - 1U);
+    for (i = 0; i < crypto_hash_sha256_BYTES; ++i) {
+        printf("%02x", (unsigned int)h[i]);
+    }
+    printf("\n");
+
+    assert(crypto_hash_bytes() > 0U);
+    assert(strcmp(crypto_hash_primitive(), "sha512") == 0);
+    assert(crypto_hash_sha256_bytes() > 0U);
+    assert(crypto_hash_sha512_bytes() >= crypto_hash_sha256_bytes());
+    assert(crypto_hash_sha512_bytes() == crypto_hash_bytes());
+
+    return 0;
 }

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

@@ -1 +1,4 @@
 24f950aac7b9ea9b3cb728228a0c82b67c39e96b4b344798870d5daee93e3ae5931baae8c7cacfea4b629452c38026a81d138bc7aad1af3ef7bfd5ec646d6c28
+a77abe1ccf8f5497e228fbc0acd73a521ededb21b89726684a6ebbc3baa32361aca5a244daa84f24bf19c68baf78e6907625a659b15479eb7bd426fc62aafa73
+12a61f4e173fb3a11c05d6471f74728f76231b4a5fcd9667cef3af87a3ae4dc2
+71cc8123fef8c236e451d3c3ddf1adae9aa6cd9521e7041769d737024900a03a

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

@@ -1,16 +1,19 @@
-#include <stdio.h>
 
 #define TEST_NAME "hash3"
 #include "cmptest.h"
 
 unsigned char x[] = "testing\n";
-unsigned char h[crypto_hash_sha512_BYTES];
+unsigned char h[crypto_hash_BYTES];
 
 int main(void)
 {
-  size_t i;
-  crypto_hash_sha512(h,x,sizeof x - 1U);
-  for (i = 0;i < crypto_hash_sha512_BYTES;++i) printf("%02x",(unsigned int) h[i]);
-  printf("\n");
-  return 0;
+    size_t i;
+
+    crypto_hash(h, x, sizeof x - 1U);
+    for (i = 0; i < crypto_hash_BYTES; ++i) {
+        printf("%02x", (unsigned int)h[i]);
+    }
+    printf("\n");
+
+    return 0;
 }

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

@@ -1,44 +1,56 @@
-#include <stdio.h>
 
 #define TEST_NAME "onetimeauth"
 #include "cmptest.h"
 
-unsigned char rs[32] = {
- 0xee,0xa6,0xa7,0x25,0x1c,0x1e,0x72,0x91
-,0x6d,0x11,0xc2,0xcb,0x21,0x4d,0x3c,0x25
-,0x25,0x39,0x12,0x1d,0x8e,0x23,0x4e,0x65
-,0x2d,0x65,0x1f,0xa4,0xc8,0xcf,0xf8,0x80
-} ;
-
-unsigned char c[131] = {
- 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
-} ;
+unsigned char rs[32]
+    = { 0xee, 0xa6, 0xa7, 0x25, 0x1c, 0x1e, 0x72, 0x91, 0x6d, 0x11, 0xc2,
+        0xcb, 0x21, 0x4d, 0x3c, 0x25, 0x25, 0x39, 0x12, 0x1d, 0x8e, 0x23,
+        0x4e, 0x65, 0x2d, 0x65, 0x1f, 0xa4, 0xc8, 0xcf, 0xf8, 0x80 };
+
+unsigned char c[131]
+    = { 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 };
 
 unsigned char a[16];
 
 int main(void)
 {
-  int i;
-  crypto_onetimeauth_poly1305(a,c,131,rs);
-  for (i = 0;i < 16;++i) {
-    printf(",0x%02x",(unsigned int) a[i]);
-    if (i % 8 == 7) printf("\n");
-  }
-  return 0;
+    crypto_onetimeauth_state st;
+    int i;
+
+    crypto_onetimeauth(a, c, 131, rs);
+    for (i = 0; i < 16; ++i) {
+        printf(",0x%02x", (unsigned int)a[i]);
+        if (i % 8 == 7)
+            printf("\n");
+    }
+
+    memset(a, 0, sizeof a);
+    crypto_onetimeauth_init(&st, rs);
+    crypto_onetimeauth_update(&st, c, 100);
+    crypto_onetimeauth_update(&st, c + 100, 31);
+    crypto_onetimeauth_final(&st, a);
+    for (i = 0; i < 16; ++i) {
+        printf(",0x%02x", (unsigned int)a[i]);
+        if (i % 8 == 7)
+            printf("\n");
+    }
+
+    assert(crypto_onetimeauth_bytes() > 0U);
+    assert(crypto_onetimeauth_keybytes() > 0U);
+    assert(strcmp(crypto_onetimeauth_primitive(), "poly1305") == 0);
+    assert(crypto_onetimeauth_poly1305_bytes() == crypto_onetimeauth_bytes());
+    assert(crypto_onetimeauth_poly1305_keybytes()
+           == crypto_onetimeauth_keybytes());
+
+    return 0;
 }