usr/src/test/zfs-tests/tests/functional/checksum/edonr/edonr_test.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://opensource.org/licenses/CDDL-1.0.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2013 Saso Kiselkov. All rights reserved.
  24  */
  25
  26 /*
  27  * This is just to keep the compiler happy about sys/time.h not declaring
  28  * gettimeofday due to -D_KERNEL (we can do this since we're actually
  29  * running in userspace, but we need -D_KERNEL for the remaining Edon-R code).
  30  */
  31 #ifdef  _KERNEL
  32 #undef  _KERNEL
  33 #endif
  34
  35 #include <sys/edonr.h>
  36 #include <stdlib.h>
  37 #include <strings.h>
  38 #include <stdio.h>
  39 #include <sys/time.h>
  40 #include <note.h>
  41
  42 /*
  43  * Test messages from:
  44  * http://csrc.nist.gov/groups/ST/toolkit/documents/Examples/SHA_All.pdf
  45  */
  46 const char      *test_msg0 = "abc";
  47 const char      *test_msg1 = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmn"
  48         "lmnomnopnopq";
  49 const char      *test_msg2 = "abcdefghbcdefghicdefghijdefghijkefghijklfghi"
  50         "jklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu";
  51
  52 /*
  53  * Test digests computed by hand. There's no formal standard or spec for edonr.
  54  */
  55 const uint8_t   edonr_224_test_digests[][28] = {
  56         {
  57                 /* for test_msg0 */
  58                 0x56, 0x63, 0xc4, 0x93, 0x95, 0x20, 0xfa, 0xf6,
  59                 0x12, 0x31, 0x65, 0xa4, 0x66, 0xf2, 0x56, 0x01,
  60                 0x95, 0x2e, 0xa9, 0xe4, 0x24, 0xdd, 0xc9, 0x6b,
  61                 0xef, 0xd0, 0x40, 0x94
  62         },
  63         {
  64                 /* for test_msg1 */
  65                 0xd0, 0x13, 0xe4, 0x87, 0x4d, 0x06, 0x8d, 0xca,
  66                 0x4e, 0x14, 0xb9, 0x37, 0x2f, 0xce, 0x12, 0x20,
  67                 0x60, 0xf8, 0x5c, 0x0a, 0xfd, 0x7a, 0x7d, 0x97,
  68                 0x88, 0x2b, 0x05, 0x75
  69         }
  70         /* no test vector for test_msg2 */
  71 };
  72
  73 const uint8_t   edonr_256_test_digests[][32] = {
  74         {
  75                 /* for test_msg0 */
  76                 0x54, 0xd7, 0x8b, 0x13, 0xc7, 0x4e, 0xda, 0x5a,
  77                 0xed, 0xc2, 0x71, 0xcc, 0x88, 0x1f, 0xb2, 0x2f,
  78                 0x83, 0x99, 0xaf, 0xd3, 0x04, 0x0b, 0x6a, 0x39,
  79                 0x2d, 0x73, 0x94, 0x05, 0x50, 0x8d, 0xd8, 0x51
  80         },
  81         {
  82                 /* for test_msg1 */
  83                 0x49, 0x2d, 0x0b, 0x19, 0xab, 0x1e, 0xde, 0x3a,
  84                 0xea, 0x9b, 0xf2, 0x39, 0x3a, 0xb1, 0x21, 0xde,
  85                 0x21, 0xf6, 0x80, 0x1f, 0xad, 0xbe, 0x8b, 0x07,
  86                 0xc7, 0xfb, 0xe6, 0x99, 0x0e, 0x4d, 0x73, 0x63
  87         }
  88         /* no test vectorfor test_msg2 */
  89 };
  90
  91 const uint8_t   edonr_384_test_digests[][48] = {
  92         {
  93                 /* for test_msg0 */
  94                 0x0e, 0x7c, 0xd7, 0x85, 0x78, 0x77, 0xe0, 0x89,
  95                 0x5b, 0x1c, 0xdf, 0x49, 0xf4, 0x1d, 0x20, 0x9c,
  96                 0x72, 0x7d, 0x2e, 0x57, 0x9b, 0x9b, 0x9a, 0xdc,
  97                 0x60, 0x27, 0x97, 0x82, 0xb9, 0x90, 0x72, 0xec,
  98                 0x7e, 0xce, 0xd3, 0x16, 0x5f, 0x47, 0x75, 0x48,
  99                 0xfa, 0x60, 0x72, 0x7e, 0x01, 0xc7, 0x7c, 0xc6
 100         },
 101         {
 102                 /* no test vector for test_msg1 */
 103                 0
 104         },
 105         {
 106                 /* for test_msg2 */
 107                 0xe2, 0x34, 0xa1, 0x02, 0x83, 0x76, 0xae, 0xe6,
 108                 0x82, 0xd9, 0x38, 0x32, 0x0e, 0x00, 0x78, 0xd2,
 109                 0x34, 0xdb, 0xb9, 0xbd, 0xf0, 0x08, 0xa8, 0x0f,
 110                 0x63, 0x1c, 0x3d, 0x4a, 0xfd, 0x0a, 0xe9, 0x59,
 111                 0xdc, 0xd4, 0xce, 0xcd, 0x8d, 0x67, 0x6c, 0xea,
 112                 0xbb, 0x1a, 0x32, 0xed, 0x5c, 0x6b, 0xf1, 0x7f
 113         }
 114 };
 115
 116 const uint8_t   edonr_512_test_digests[][64] = {
 117         {
 118                 /* for test_msg0 */
 119                 0x1b, 0x14, 0xdb, 0x15, 0x5f, 0x1d, 0x40, 0x65,
 120                 0x94, 0xb8, 0xce, 0xf7, 0x0a, 0x43, 0x62, 0xec,
 121                 0x6b, 0x5d, 0xe6, 0xa5, 0xda, 0xf5, 0x0e, 0xc9,
 122                 0x99, 0xe9, 0x87, 0xc1, 0x9d, 0x30, 0x49, 0xe2,
 123                 0xde, 0x59, 0x77, 0xbb, 0x05, 0xb1, 0xbb, 0x22,
 124                 0x00, 0x50, 0xa1, 0xea, 0x5b, 0x46, 0xa9, 0xf1,
 125                 0x74, 0x0a, 0xca, 0xfb, 0xf6, 0xb4, 0x50, 0x32,
 126                 0xad, 0xc9, 0x0c, 0x62, 0x83, 0x72, 0xc2, 0x2b
 127         },
 128         {
 129                 /* no test vector for test_msg1 */
 130                 0
 131         },
 132         {
 133                 /* for test_msg2 */
 134                 0x53, 0x51, 0x07, 0x0d, 0xc5, 0x1c, 0x3b, 0x2b,
 135                 0xac, 0xa5, 0xa6, 0x0d, 0x02, 0x52, 0xcc, 0xb4,
 136                 0xe4, 0x92, 0x1a, 0x96, 0xfe, 0x5a, 0x69, 0xe7,
 137                 0x6d, 0xad, 0x48, 0xfd, 0x21, 0xa0, 0x84, 0x5a,
 138                 0xd5, 0x7f, 0x88, 0x0b, 0x3e, 0x4a, 0x90, 0x7b,
 139                 0xc5, 0x03, 0x15, 0x18, 0x42, 0xbb, 0x94, 0x9e,
 140                 0x1c, 0xba, 0x74, 0x39, 0xa6, 0x40, 0x9a, 0x34,
 141                 0xb8, 0x43, 0x6c, 0xb4, 0x69, 0x21, 0x58, 0x3c
 142         }
 143 };
 144
 145 int
 146 main(int argc, char *argv[])
 147 {
 148         boolean_t       failed = B_FALSE;
 149         uint64_t        cpu_mhz = 0;
 150
 151         if (argc == 2)
 152                 cpu_mhz = atoi(argv[1]);
 153
 154 #define EDONR_ALGO_TEST(_m, mode, testdigest)                           \
 155         do {                                                            \
 156                 EdonRState      ctx;                                    \
 157                 uint8_t         digest[mode / 8];                       \
 158                 EdonRInit(&ctx, mode);                                  \
 159                 EdonRUpdate(&ctx, (const uint8_t *) _m, strlen(_m) * 8);\
 160                 EdonRFinal(&ctx, digest);                               \
 161                 (void) printf("Edon-R-%-6sMessage: " #_m                \
 162                     "\tResult: ", #mode);                               \
 163                 if (bcmp(digest, testdigest, mode / 8) == 0) {          \
 164                         (void) printf("OK\n");                          \
 165                 } else {                                                \
 166                         (void) printf("FAILED!\n");                     \
 167                         failed = B_TRUE;                                \
 168                 }                                                       \
 169                 NOTE(CONSTCOND)                                         \
 170         } while (0)
 171
 172 #define EDONR_PERF_TEST(mode)                                           \
 173         do {                                                            \
 174                 EdonRState      ctx;                                    \
 175                 uint8_t         digest[mode / 8];                       \
 176                 uint8_t         block[131072];                          \
 177                 uint64_t        delta;                                  \
 178                 double          cpb = 0;                                \
 179                 int             i;                                      \
 180                 struct timeval  start, end;                             \
 181                 bzero(block, sizeof (block));                           \
 182                 (void) gettimeofday(&start, NULL);                      \
 183                 EdonRInit(&ctx, mode);                                  \
 184                 for (i = 0; i < 8192; i++)                              \
 185                         EdonRUpdate(&ctx, block, sizeof (block) * 8);   \
 186                 EdonRFinal(&ctx, digest);                               \
 187                 (void) gettimeofday(&end, NULL);                        \
 188                 delta = (end.tv_sec * 1000000llu + end.tv_usec) -       \
 189                     (start.tv_sec * 1000000llu + start.tv_usec);        \
 190                 if (cpu_mhz != 0) {                                     \
 191                         cpb = (cpu_mhz * 1e6 * ((double)delta /         \
 192                             1000000)) / (8192 * 128 * 1024);            \
 193                 }                                                       \
 194                 (void) printf("Edon-R-%-6s%llu us (%.02f CPB)\n", #mode,\
 195                     (u_longlong_t)delta, cpb);                          \
 196                 NOTE(CONSTCOND)                                         \
 197         } while (0)
 198
 199         (void) printf("Running algorithm correctness tests:\n");
 200         EDONR_ALGO_TEST(test_msg0, 224, edonr_224_test_digests[0]);
 201         EDONR_ALGO_TEST(test_msg1, 224, edonr_224_test_digests[1]);
 202         EDONR_ALGO_TEST(test_msg0, 256, edonr_256_test_digests[0]);
 203         EDONR_ALGO_TEST(test_msg1, 256, edonr_256_test_digests[1]);
 204         EDONR_ALGO_TEST(test_msg0, 384, edonr_384_test_digests[0]);
 205         EDONR_ALGO_TEST(test_msg2, 384, edonr_384_test_digests[2]);
 206         EDONR_ALGO_TEST(test_msg0, 512, edonr_512_test_digests[0]);
 207         EDONR_ALGO_TEST(test_msg2, 512, edonr_512_test_digests[2]);
 208         if (failed)
 209                 return (1);
 210
 211         (void) printf("Running performance tests (hashing 1024 MiB of "
 212             "data):\n");
 213         EDONR_PERF_TEST(256);
 214         EDONR_PERF_TEST(512);
 215
 216         return (0);
 217 }