metamorphic.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    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 }

Cache object: 686074e2c84f93874ddbebf060e5874a

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/contrib/libsodium/test/default/metamorphic.c

FreeBSD/Linux Kernel Cross Reference
sys/contrib/libsodium/test/default/metamorphic.c