tests/zfs-tests/tests/functional/checksum/sha2_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 SHA2 code).
  30  */
  31 #ifdef  _KERNEL
  32 #undef  _KERNEL
  33 #endif
  34
  35 #include <stdarg.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <stdio.h>
  39 #include <sys/time.h>
  40 #define _SHA2_IMPL
  41 #include <sys/sha2.h>
  42 #define NOTE(x)
  43 typedef enum boolean { B_FALSE, B_TRUE } boolean_t;
  44 typedef unsigned long long      u_longlong_t;
  45
  46
  47 /*
  48  * Test messages from:
  49  * http://csrc.nist.gov/groups/ST/toolkit/documents/Examples/SHA_All.pdf
  50  */
  51
  52 const char      *test_msg0 = "abc";
  53 const char      *test_msg1 = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmn"
  54         "lmnomnopnopq";
  55 const char      *test_msg2 = "abcdefghbcdefghicdefghijdefghijkefghijklfghi"
  56         "jklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu";
  57
  58 /*
  59  * Test digests from:
  60  * http://csrc.nist.gov/groups/ST/toolkit/documents/Examples/SHA_All.pdf
  61  */
  62 const uint8_t   sha256_test_digests[][32] = {
  63         {
  64                 /* for test_msg0 */
  65                 0xBA, 0x78, 0x16, 0xBF, 0x8F, 0x01, 0xCF, 0xEA,
  66                 0x41, 0x41, 0x40, 0xDE, 0x5D, 0xAE, 0x22, 0x23,
  67                 0xB0, 0x03, 0x61, 0xA3, 0x96, 0x17, 0x7A, 0x9C,
  68                 0xB4, 0x10, 0xFF, 0x61, 0xF2, 0x00, 0x15, 0xAD
  69         },
  70         {
  71                 /* for test_msg1 */
  72                 0x24, 0x8D, 0x6A, 0x61, 0xD2, 0x06, 0x38, 0xB8,
  73                 0xE5, 0xC0, 0x26, 0x93, 0x0C, 0x3E, 0x60, 0x39,
  74                 0xA3, 0x3C, 0xE4, 0x59, 0x64, 0xFF, 0x21, 0x67,
  75                 0xF6, 0xEC, 0xED, 0xD4, 0x19, 0xDB, 0x06, 0xC1
  76         }
  77         /* no test vector for test_msg2 */
  78 };
  79
  80 const uint8_t   sha384_test_digests[][48] = {
  81         {
  82                 /* for test_msg0 */
  83                 0xCB, 0x00, 0x75, 0x3F, 0x45, 0xA3, 0x5E, 0x8B,
  84                 0xB5, 0xA0, 0x3D, 0x69, 0x9A, 0xC6, 0x50, 0x07,
  85                 0x27, 0x2C, 0x32, 0xAB, 0x0E, 0xDE, 0xD1, 0x63,
  86                 0x1A, 0x8B, 0x60, 0x5A, 0x43, 0xFF, 0x5B, 0xED,
  87                 0x80, 0x86, 0x07, 0x2B, 0xA1, 0xE7, 0xCC, 0x23,
  88                 0x58, 0xBA, 0xEC, 0xA1, 0x34, 0xC8, 0x25, 0xA7
  89         },
  90         {
  91                 /* no test vector for test_msg1 */
  92                 0
  93         },
  94         {
  95                 /* for test_msg2 */
  96                 0x09, 0x33, 0x0C, 0x33, 0xF7, 0x11, 0x47, 0xE8,
  97                 0x3D, 0x19, 0x2F, 0xC7, 0x82, 0xCD, 0x1B, 0x47,
  98                 0x53, 0x11, 0x1B, 0x17, 0x3B, 0x3B, 0x05, 0xD2,
  99                 0x2F, 0xA0, 0x80, 0x86, 0xE3, 0xB0, 0xF7, 0x12,
 100                 0xFC, 0xC7, 0xC7, 0x1A, 0x55, 0x7E, 0x2D, 0xB9,
 101                 0x66, 0xC3, 0xE9, 0xFA, 0x91, 0x74, 0x60, 0x39
 102         }
 103 };
 104
 105 const uint8_t   sha512_test_digests[][64] = {
 106         {
 107                 /* for test_msg0 */
 108                 0xDD, 0xAF, 0x35, 0xA1, 0x93, 0x61, 0x7A, 0xBA,
 109                 0xCC, 0x41, 0x73, 0x49, 0xAE, 0x20, 0x41, 0x31,
 110                 0x12, 0xE6, 0xFA, 0x4E, 0x89, 0xA9, 0x7E, 0xA2,
 111                 0x0A, 0x9E, 0xEE, 0xE6, 0x4B, 0x55, 0xD3, 0x9A,
 112                 0x21, 0x92, 0x99, 0x2A, 0x27, 0x4F, 0xC1, 0xA8,
 113                 0x36, 0xBA, 0x3C, 0x23, 0xA3, 0xFE, 0xEB, 0xBD,
 114                 0x45, 0x4D, 0x44, 0x23, 0x64, 0x3C, 0xE8, 0x0E,
 115                 0x2A, 0x9A, 0xC9, 0x4F, 0xA5, 0x4C, 0xA4, 0x9F
 116         },
 117         {
 118                 /* no test vector for test_msg1 */
 119                 0
 120         },
 121         {
 122                 /* for test_msg2 */
 123                 0x8E, 0x95, 0x9B, 0x75, 0xDA, 0xE3, 0x13, 0xDA,
 124                 0x8C, 0xF4, 0xF7, 0x28, 0x14, 0xFC, 0x14, 0x3F,
 125                 0x8F, 0x77, 0x79, 0xC6, 0xEB, 0x9F, 0x7F, 0xA1,
 126                 0x72, 0x99, 0xAE, 0xAD, 0xB6, 0x88, 0x90, 0x18,
 127                 0x50, 0x1D, 0x28, 0x9E, 0x49, 0x00, 0xF7, 0xE4,
 128                 0x33, 0x1B, 0x99, 0xDE, 0xC4, 0xB5, 0x43, 0x3A,
 129                 0xC7, 0xD3, 0x29, 0xEE, 0xB6, 0xDD, 0x26, 0x54,
 130                 0x5E, 0x96, 0xE5, 0x5B, 0x87, 0x4B, 0xE9, 0x09
 131         }
 132 };
 133
 134 const uint8_t   sha512_224_test_digests[][28] = {
 135         {
 136                 /* for test_msg0 */
 137                 0x46, 0x34, 0x27, 0x0F, 0x70, 0x7B, 0x6A, 0x54,
 138                 0xDA, 0xAE, 0x75, 0x30, 0x46, 0x08, 0x42, 0xE2,
 139                 0x0E, 0x37, 0xED, 0x26, 0x5C, 0xEE, 0xE9, 0xA4,
 140                 0x3E, 0x89, 0x24, 0xAA
 141         },
 142         {
 143                 /* no test vector for test_msg1 */
 144                 0
 145         },
 146         {
 147                 /* for test_msg2 */
 148                 0x23, 0xFE, 0xC5, 0xBB, 0x94, 0xD6, 0x0B, 0x23,
 149                 0x30, 0x81, 0x92, 0x64, 0x0B, 0x0C, 0x45, 0x33,
 150                 0x35, 0xD6, 0x64, 0x73, 0x4F, 0xE4, 0x0E, 0x72,
 151                 0x68, 0x67, 0x4A, 0xF9
 152         }
 153 };
 154
 155 const uint8_t   sha512_256_test_digests[][32] = {
 156         {
 157                 /* for test_msg0 */
 158                 0x53, 0x04, 0x8E, 0x26, 0x81, 0x94, 0x1E, 0xF9,
 159                 0x9B, 0x2E, 0x29, 0xB7, 0x6B, 0x4C, 0x7D, 0xAB,
 160                 0xE4, 0xC2, 0xD0, 0xC6, 0x34, 0xFC, 0x6D, 0x46,
 161                 0xE0, 0xE2, 0xF1, 0x31, 0x07, 0xE7, 0xAF, 0x23
 162         },
 163         {
 164                 /* no test vector for test_msg1 */
 165                 0
 166         },
 167         {
 168                 /* for test_msg2 */
 169                 0x39, 0x28, 0xE1, 0x84, 0xFB, 0x86, 0x90, 0xF8,
 170                 0x40, 0xDA, 0x39, 0x88, 0x12, 0x1D, 0x31, 0xBE,
 171                 0x65, 0xCB, 0x9D, 0x3E, 0xF8, 0x3E, 0xE6, 0x14,
 172                 0x6F, 0xEA, 0xC8, 0x61, 0xE1, 0x9B, 0x56, 0x3A
 173         }
 174 };
 175
 176 /*
 177  * Local reimplementation of cmn_err, since it's used in sha2.c.
 178  */
 179 /*ARGSUSED*/
 180 void
 181 cmn_err(int level, char *format, ...)
 182 {
 183         va_list ap;
 184         va_start(ap, format);
 185         /* LINTED: E_SEC_PRINTF_VAR_FMT */
 186         (void) vfprintf(stderr, format, ap);
 187         va_end(ap);
 188 }
 189
 190 int
 191 main(int argc, char *argv[])
 192 {
 193         boolean_t       failed = B_FALSE;
 194         uint64_t        cpu_mhz = 0;
 195
 196         if (argc == 2)
 197                 cpu_mhz = atoi(argv[1]);
 198
 199 #define SHA2_ALGO_TEST(_m, mode, diglen, testdigest)                    \
 200         do {                                                            \
 201                 SHA2_CTX                ctx;                            \
 202                 uint8_t                 digest[diglen / 8];             \
 203                 SHA2Init(SHA ## mode ## _MECH_INFO_TYPE, &ctx);         \
 204                 SHA2Update(&ctx, _m, strlen(_m));                       \
 205                 SHA2Final(digest, &ctx);                                \
 206                 (void) printf("SHA%-9sMessage: " #_m                    \
 207                     "\tResult: ", #mode);                               \
 208                 if (bcmp(digest, testdigest, diglen / 8) == 0) {        \
 209                         (void) printf("OK\n");                          \
 210                 } else {                                                \
 211                         (void) printf("FAILED!\n");                     \
 212                         failed = B_TRUE;                                \
 213                 }                                                       \
 214                 NOTE(CONSTCOND)                                         \
 215         } while (0)
 216
 217 #define SHA2_PERF_TEST(mode, diglen)                                    \
 218         do {                                                            \
 219                 SHA2_CTX        ctx;                                    \
 220                 uint8_t         digest[diglen / 8];                     \
 221                 uint8_t         block[131072];                          \
 222                 uint64_t        delta;                                  \
 223                 double          cpb = 0;                                \
 224                 int             i;                                      \
 225                 struct timeval  start, end;                             \
 226                 bzero(block, sizeof (block));                           \
 227                 (void) gettimeofday(&start, NULL);                      \
 228                 SHA2Init(SHA ## mode ## _MECH_INFO_TYPE, &ctx);         \
 229                 for (i = 0; i < 8192; i++)                              \
 230                         SHA2Update(&ctx, block, sizeof (block));        \
 231                 SHA2Final(digest, &ctx);                                \
 232                 (void) gettimeofday(&end, NULL);                        \
 233                 delta = (end.tv_sec * 1000000llu + end.tv_usec) -       \
 234                     (start.tv_sec * 1000000llu + start.tv_usec);        \
 235                 if (cpu_mhz != 0) {                                     \
 236                         cpb = (cpu_mhz * 1e6 * ((double)delta /         \
 237                             1000000)) / (8192 * 128 * 1024);            \
 238                 }                                                       \
 239                 (void) printf("SHA%-9s%llu us (%.02f CPB)\n", #mode,    \
 240                     (u_longlong_t)delta, cpb);                          \
 241                 NOTE(CONSTCOND)                                         \
 242         } while (0)
 243
 244         (void) printf("Running algorithm correctness tests:\n");
 245         SHA2_ALGO_TEST(test_msg0, 256, 256, sha256_test_digests[0]);
 246         SHA2_ALGO_TEST(test_msg1, 256, 256, sha256_test_digests[1]);
 247         SHA2_ALGO_TEST(test_msg0, 384, 384, sha384_test_digests[0]);
 248         SHA2_ALGO_TEST(test_msg2, 384, 384, sha384_test_digests[2]);
 249         SHA2_ALGO_TEST(test_msg0, 512, 512, sha512_test_digests[0]);
 250         SHA2_ALGO_TEST(test_msg2, 512, 512, sha512_test_digests[2]);
 251         SHA2_ALGO_TEST(test_msg0, 512_224, 224, sha512_224_test_digests[0]);
 252         SHA2_ALGO_TEST(test_msg2, 512_224, 224, sha512_224_test_digests[2]);
 253         SHA2_ALGO_TEST(test_msg0, 512_256, 256, sha512_256_test_digests[0]);
 254         SHA2_ALGO_TEST(test_msg2, 512_256, 256, sha512_256_test_digests[2]);
 255
 256         if (failed)
 257                 return (1);
 258
 259         (void) printf("Running performance tests (hashing 1024 MiB of "
 260             "data):\n");
 261         SHA2_PERF_TEST(256, 256);
 262         SHA2_PERF_TEST(512, 512);
 263
 264         return (0);
 265 }