Home | History | Annotate | Line # | Download | only in default 
      1 
      2 #define TEST_NAME "metamorphic"
      3 #include "cmptest.h"
      4 
      5 #define MAXLEN 512
      6 #define MAX_ITER 1000
      7 
      8 static void
      9 mm_generichash(void)
     10 {
     11     crypto_generichash_state st;
     12     unsigned char *h, *h2;
     13     unsigned char *k;
     14     unsigned char *m;
     15     size_t         hlen;
     16     size_t         klen;
     17     size_t         mlen;
     18     size_t         l1, l2;
     19     int            i;
     20 
     21     for (i = 0; i < MAX_ITER; i++) {
     22         mlen = randombytes_uniform(MAXLEN);
     23         m = (unsigned char *) sodium_malloc(mlen);
     24         klen = randombytes_uniform(crypto_generichash_KEYBYTES_MAX -
     25                                    crypto_generichash_KEYBYTES_MIN + 1U)
     26             + crypto_generichash_KEYBYTES_MIN;
     27         k = (unsigned char *) sodium_malloc(klen);
     28         hlen = randombytes_uniform(crypto_generichash_BYTES_MAX -
     29                                    crypto_generichash_BYTES_MIN + 1U)
     30             + crypto_generichash_BYTES_MIN;
     31         h = (unsigned char *) sodium_malloc(hlen);
     32         h2 = (unsigned char *) sodium_malloc(hlen);
     33 
     34         randombytes_buf(k, klen);
     35         randombytes_buf(m, mlen);
     36 
     37         crypto_generichash_init(&st, k, klen, hlen);
     38         l1 = randombytes_uniform((uint32_t) mlen);
     39         l2 = randombytes_uniform((uint32_t) (mlen - l1));
     40         crypto_generichash_update(&st, m, l1);
     41         crypto_generichash_update(&st, m + l1, l2);
     42         crypto_generichash_update(&st, m + l1 + l2, mlen - l1 - l2);
     43         crypto_generichash_final(&st, h, hlen);
     44 
     45         crypto_generichash(h2, hlen, m, mlen, k, klen);
     46 
     47         assert(memcmp(h, h2, hlen) == 0);
     48 
     49         sodium_free(h2);
     50         sodium_free(h);
     51         sodium_free(k);
     52         sodium_free(m);
     53     }
     54 }
     55 
     56 static void
     57 mm_onetimeauth(void)
     58 {
     59     crypto_onetimeauth_state st;
     60     unsigned char *h, *h2;
     61     unsigned char *k;
     62     unsigned char *m;
     63     size_t         mlen;
     64     size_t         l1, l2;
     65     int            i;
     66 
     67     for (i = 0; i < MAX_ITER; i++) {
     68         mlen = randombytes_uniform(MAXLEN);
     69         m = (unsigned char *) sodium_malloc(mlen);
     70         k = (unsigned char *) sodium_malloc(crypto_onetimeauth_KEYBYTES);
     71         h = (unsigned char *) sodium_malloc(crypto_onetimeauth_BYTES);
     72         h2 = (unsigned char *) sodium_malloc(crypto_onetimeauth_BYTES);
     73 
     74         crypto_onetimeauth_keygen(k);
     75         randombytes_buf(m, mlen);
     76 
     77         crypto_onetimeauth_init(&st, k);
     78         l1 = randombytes_uniform((uint32_t) mlen);
     79         l2 = randombytes_uniform((uint32_t) (mlen - l1));
     80         crypto_onetimeauth_update(&st, m, l1);
     81         crypto_onetimeauth_update(&st, m + l1, l2);
     82         crypto_onetimeauth_update(&st, m + l1 + l2, mlen - l1 - l2);
     83         crypto_onetimeauth_final(&st, h);
     84 
     85         crypto_onetimeauth(h2, m, mlen, k);
     86 
     87         assert(memcmp(h, h2, crypto_onetimeauth_BYTES) == 0);
     88 
     89         sodium_free(h2);
     90         sodium_free(h);
     91         sodium_free(k);
     92         sodium_free(m);
     93     }
     94 }
     95 
     96 static void
     97 mm_hmacsha256(void)
     98 {
     99     crypto_auth_hmacsha256_state st;
    100     unsigned char *h, *h2;
    101     unsigned char *k;
    102     unsigned char *m;
    103     size_t         mlen;
    104     size_t         l1, l2;
    105     int            i;
    106 
    107     for (i = 0; i < MAX_ITER; i++) {
    108         mlen = randombytes_uniform(MAXLEN);
    109         m = (unsigned char *) sodium_malloc(mlen);
    110         k = (unsigned char *) sodium_malloc(crypto_auth_hmacsha256_KEYBYTES);
    111         h = (unsigned char *) sodium_malloc(crypto_auth_hmacsha256_BYTES);
    112         h2 = (unsigned char *) sodium_malloc(crypto_auth_hmacsha256_BYTES);
    113 
    114         crypto_auth_hmacsha256_keygen(k);
    115         randombytes_buf(m, mlen);
    116 
    117         crypto_auth_hmacsha256_init(&st, k, crypto_auth_hmacsha256_KEYBYTES);
    118         l1 = randombytes_uniform((uint32_t) mlen);
    119         l2 = randombytes_uniform((uint32_t) (mlen - l1));
    120         crypto_auth_hmacsha256_update(&st, m, l1);
    121         crypto_auth_hmacsha256_update(&st, m + l1, l2);
    122         crypto_auth_hmacsha256_update(&st, m + l1 + l2, mlen - l1 - l2);
    123         crypto_auth_hmacsha256_final(&st, h);
    124 
    125         crypto_auth_hmacsha256(h2, m, mlen, k);
    126 
    127         assert(memcmp(h, h2, crypto_auth_hmacsha256_BYTES) == 0);
    128 
    129         sodium_free(h2);
    130         sodium_free(h);
    131         sodium_free(k);
    132         sodium_free(m);
    133     }
    134 }
    135 
    136 static void
    137 mm_hmacsha512(void)
    138 {
    139     crypto_auth_hmacsha512_state st;
    140     unsigned char *h, *h2;
    141     unsigned char *k;
    142     unsigned char *m;
    143     size_t         mlen;
    144     size_t         l1, l2;
    145     int            i;
    146 
    147     for (i = 0; i < MAX_ITER; i++) {
    148         mlen = randombytes_uniform(MAXLEN);
    149         m = (unsigned char *) sodium_malloc(mlen);
    150         k = (unsigned char *) sodium_malloc(crypto_auth_hmacsha512_KEYBYTES);
    151         h = (unsigned char *) sodium_malloc(crypto_auth_hmacsha512_BYTES);
    152         h2 = (unsigned char *) sodium_malloc(crypto_auth_hmacsha512_BYTES);
    153 
    154         crypto_auth_hmacsha512_keygen(k);
    155         randombytes_buf(m, mlen);
    156 
    157         crypto_auth_hmacsha512_init(&st, k, crypto_auth_hmacsha512_KEYBYTES);
    158         l1 = randombytes_uniform((uint32_t) mlen);
    159         l2 = randombytes_uniform((uint32_t) (mlen - l1));
    160         crypto_auth_hmacsha512_update(&st, m, l1);
    161         crypto_auth_hmacsha512_update(&st, m + l1, l2);
    162         crypto_auth_hmacsha512_update(&st, m + l1 + l2, mlen - l1 - l2);
    163         crypto_auth_hmacsha512_final(&st, h);
    164 
    165         crypto_auth_hmacsha512(h2, m, mlen, k);
    166 
    167         assert(memcmp(h, h2, crypto_auth_hmacsha512_BYTES) == 0);
    168 
    169         sodium_free(h2);
    170         sodium_free(h);
    171         sodium_free(k);
    172         sodium_free(m);
    173     }
    174 }
    175 
    176 int
    177 main(void)
    178 {
    179     mm_generichash();
    180     mm_onetimeauth();
    181     mm_hmacsha256();
    182     mm_hmacsha512();
    183 
    184     printf("OK\n");
    185 
    186     return 0;
    187 }
    188