release/src-rt-6.x.4708/router/libsodium/test/default/generichash3.c

   1
   2 #define TEST_NAME "generichash3"
   3 #include "cmptest.h"
   4
   5 int main(void)
   6 {
   7 #define MAXLEN 64
   8     crypto_generichash_blake2b_state st;
   9     unsigned char salt[crypto_generichash_blake2b_SALTBYTES]
  10         = { '5', 'b', '6', 'b', '4', '1', 'e', 'd',
  11             '9', 'b', '3', '4', '3', 'f', 'e', '0' };
  12     unsigned char personal[crypto_generichash_blake2b_PERSONALBYTES]
  13         = { '5', '1', '2', '6', 'f', 'b', '2', 'a',
  14             '3', '7', '4', '0', '0', 'd', '2', 'a' };
  15     unsigned char in[MAXLEN], out[crypto_generichash_blake2b_BYTES_MAX],
  16         k[crypto_generichash_blake2b_KEYBYTES_MAX];
  17     size_t h, i, j;
  18
  19     for (h = 0; h < crypto_generichash_blake2b_KEYBYTES_MAX; ++h)
  20         k[h] = h;
  21
  22     for (i = 0; i < MAXLEN; ++i) {
  23         in[i] = i;
  24         crypto_generichash_blake2b_init_salt_personal(
  25             &st, k, 1 + i % crypto_generichash_blake2b_KEYBYTES_MAX,
  26             1 + i % crypto_generichash_blake2b_BYTES_MAX, salt, personal);
  27         crypto_generichash_blake2b_update(&st, in, i);
  28         crypto_generichash_blake2b_final(
  29             &st, out, 1 + i % crypto_generichash_blake2b_BYTES_MAX);
  30         for (j = 0; j < 1 + i % crypto_generichash_blake2b_BYTES_MAX; ++j) {
  31             printf("%02x", (unsigned int)out[j]);
  32         }
  33         printf("\n");
  34     }
  35
  36     memset(out, 0, sizeof out);
  37     crypto_generichash_blake2b_init_salt_personal(
  38         &st, k, 0U, crypto_generichash_blake2b_BYTES_MAX, salt, personal);
  39     crypto_generichash_blake2b_update(&st, in, MAXLEN);
  40     crypto_generichash_blake2b_final(&st, out,
  41                                      crypto_generichash_blake2b_BYTES_MAX);
  42     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
  43         printf("%02x", (unsigned int)out[j]);
  44     }
  45     printf("\n");
  46
  47     memset(out, 0, sizeof out);
  48     crypto_generichash_blake2b_init_salt_personal(
  49         &st, NULL, 1U, crypto_generichash_blake2b_BYTES_MAX, salt, personal);
  50     crypto_generichash_blake2b_update(&st, in, MAXLEN);
  51     crypto_generichash_blake2b_final(&st, out,
  52                                      crypto_generichash_blake2b_BYTES_MAX);
  53     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
  54         printf("%02x", (unsigned int)out[j]);
  55     }
  56     printf("\n");
  57
  58     memset(out, 0, sizeof out);
  59     crypto_generichash_blake2b_init_salt_personal(
  60         &st, k, crypto_generichash_blake2b_KEYBYTES_MAX,
  61     crypto_generichash_blake2b_BYTES_MAX, NULL, personal);
  62     crypto_generichash_blake2b_update(&st, in, MAXLEN);
  63     crypto_generichash_blake2b_final(&st, out,
  64                                      crypto_generichash_blake2b_BYTES_MAX);
  65     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
  66         printf("%02x", (unsigned int)out[j]);
  67     }
  68     printf("\n");
  69
  70     memset(out, 0, sizeof out);
  71     crypto_generichash_blake2b_init_salt_personal(
  72         &st, k, crypto_generichash_blake2b_KEYBYTES_MAX,
  73         crypto_generichash_blake2b_BYTES_MAX, salt, NULL);
  74     crypto_generichash_blake2b_update(&st, in, MAXLEN);
  75     assert(crypto_generichash_blake2b_final(
  76         &st, out, crypto_generichash_blake2b_BYTES_MAX + 1U) == -1);
  77     crypto_generichash_blake2b_final(
  78         &st, out, crypto_generichash_blake2b_BYTES_MAX);
  79     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
  80         printf("%02x", (unsigned int)out[j]);
  81     }
  82     printf("\n");
  83
  84     memset(out, 0, sizeof out);
  85     crypto_generichash_blake2b_salt_personal(
  86         out, crypto_generichash_blake2b_BYTES_MAX, in, MAXLEN,
  87         k, 0U, salt, personal);
  88     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
  89         printf("%02x", (unsigned int)out[j]);
  90     }
  91     printf("\n");
  92
  93     memset(out, 0, sizeof out);
  94     crypto_generichash_blake2b_salt_personal(
  95         out, crypto_generichash_blake2b_BYTES_MAX, in, MAXLEN,
  96         NULL, crypto_generichash_blake2b_KEYBYTES_MAX, salt, personal);
  97     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
  98         printf("%02x", (unsigned int)out[j]);
  99     }
 100     printf("\n");
 101
 102     memset(out, 0, sizeof out);
 103     crypto_generichash_blake2b_salt_personal(
 104         out, crypto_generichash_blake2b_BYTES_MAX, in, MAXLEN,
 105         k, crypto_generichash_blake2b_KEYBYTES_MAX, salt, personal);
 106     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
 107         printf("%02x", (unsigned int)out[j]);
 108     }
 109     printf("\n");
 110
 111     memset(out, 0, sizeof out);
 112     crypto_generichash_blake2b_salt_personal(
 113         out, crypto_generichash_blake2b_BYTES_MAX, in, MAXLEN,
 114         k, crypto_generichash_blake2b_KEYBYTES_MAX, NULL, personal);
 115     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
 116         printf("%02x", (unsigned int)out[j]);
 117     }
 118     printf("\n");
 119
 120     memset(out, 0, sizeof out);
 121     crypto_generichash_blake2b_salt_personal(
 122         out, crypto_generichash_blake2b_BYTES_MAX, in, MAXLEN,
 123         k, crypto_generichash_blake2b_KEYBYTES_MAX, salt, NULL);
 124     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
 125         printf("%02x", (unsigned int)out[j]);
 126     }
 127     printf("\n");
 128
 129     crypto_generichash_blake2b_init_salt_personal(&st, NULL, 0U, crypto_generichash_BYTES,
 130                                                   NULL, personal);
 131     crypto_generichash_blake2b_update(&st, in, MAXLEN);
 132     crypto_generichash_blake2b_final(&st, out, crypto_generichash_blake2b_BYTES_MAX);
 133     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
 134         printf("%02x", (unsigned int)out[j]);
 135     }
 136     printf("\n");
 137
 138     crypto_generichash_blake2b_init_salt_personal(&st, NULL, 0U, crypto_generichash_BYTES,
 139                                                   salt, NULL);
 140     crypto_generichash_blake2b_update(&st, in, MAXLEN);
 141     crypto_generichash_blake2b_final(&st, out, crypto_generichash_blake2b_BYTES_MAX);
 142     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
 143         printf("%02x", (unsigned int)out[j]);
 144     }
 145     printf("\n");
 146
 147     assert(crypto_generichash_blake2b_init_salt_personal(&st, k, sizeof k, 0U,
 148                                                          salt, personal) == -1);
 149     assert(crypto_generichash_blake2b_init_salt_personal(&st, k, sizeof k,
 150                                                          crypto_generichash_BYTES_MAX + 1U,
 151                                                          salt, personal) == -1);
 152     assert(crypto_generichash_blake2b_init_salt_personal(&st, k,
 153                                                          crypto_generichash_KEYBYTES_MAX + 1U,
 154                                                          sizeof out, salt, personal) == -1);
 155
 156     assert(crypto_generichash_blake2b_salt_personal(out, 0U, in, MAXLEN,
 157                                                     k, sizeof k,
 158                                                     salt, personal) == -1);
 159     assert(crypto_generichash_blake2b_salt_personal(out, crypto_generichash_BYTES_MAX + 1U,
 160                                                     in, MAXLEN, k, sizeof k,
 161                                                     salt, personal) == -1);
 162     assert(crypto_generichash_blake2b_salt_personal(out, sizeof out, in, MAXLEN,
 163                                                     k, crypto_generichash_KEYBYTES_MAX + 1U,
 164                                                     salt, personal) == -1);
 165     assert(crypto_generichash_blake2b_init_salt_personal(&st, k, sizeof k, crypto_generichash_BYTES,
 166                                                          NULL, personal) == 0);
 167     assert(crypto_generichash_blake2b_init_salt_personal(&st, k, sizeof k, crypto_generichash_BYTES,
 168                                                          salt, NULL) == 0);
 169     return 0;
 170 }