pd.if.org Git - zpackage/blob - libtomcrypt/src/mac/hmac/hmac_test.c

   1 /* LibTomCrypt, modular cryptographic library -- Tom St Denis
   2  *
   3  * LibTomCrypt is a library that provides various cryptographic
   4  * algorithms in a highly modular and flexible manner.
   5  *
   6  * The library is free for all purposes without any express
   7  * guarantee it works.
   8  */
   9 #include "tomcrypt.h"
  10
  11 /**
  12   @file hmac_test.c
  13   HMAC support, self-test, Tom St Denis/Dobes Vandermeer/Steffen Jaeckel
  14 */
  15
  16 #ifdef LTC_HMAC
  17
  18 #define LTC_HMAC_BLOCKSIZE hash_descriptor[hash].blocksize
  19
  20 /*
  21     TEST CASES SOURCE:
  22
  23 Network Working Group                                          P. Cheng
  24 Request for Comments: 2202                                          IBM
  25 Category: Informational                                        R. Glenn
  26                                                                    NIST
  27                                                          September 1997
  28
  29                  Test Cases for HMAC-MD5 and HMAC-SHA-1
  30
  31 *******************************************************************************
  32
  33 Network Working Group                                            J. Kapp
  34 Request for Comments: 2286                           Reaper Technologies
  35 Category: Informational                                    February 1998
  36
  37             Test Cases for HMAC-RIPEMD160 and HMAC-RIPEMD128
  38
  39 *******************************************************************************
  40
  41 Network Working Group                                         M. Nystrom
  42 Request for Comments: 4231                                  RSA Security
  43 Category: Standards Track                                  December 2005
  44
  45      Identifiers and Test Vectors for HMAC-SHA-224, HMAC-SHA-256,
  46                      HMAC-SHA-384, and HMAC-SHA-512
  47 */
  48
  49 /**
  50   HMAC self-test
  51   @return CRYPT_OK if successful, CRYPT_NOP if tests have been disabled.
  52 */
  53 int hmac_test(void)
  54 {
  55  #ifndef LTC_TEST
  56     return CRYPT_NOP;
  57  #else
  58     unsigned char digest[MAXBLOCKSIZE];
  59     int i;
  60
  61     static const unsigned char hmac_test_case_keys[][136] = {
  62         { /* 1 */
  63             0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
  64             0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
  65             0x0b, 0x0b, 0x0b, 0x0b
  66         },
  67 #ifdef LTC_TEST_EXT
  68         { /* 2 */
  69             0x4a, 0x65, 0x66, 0x65
  70         },
  71         { /* 4 */
  72             0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
  73             0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
  74             0x15, 0x16, 0x17, 0x18, 0x19
  75         },
  76         { /* 5 */
  77             0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
  78             0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
  79             0x0c, 0x0c, 0x0c, 0x0c
  80         },
  81         { /* 3, 6, 7 */
  82             0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  83             0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  84             0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  85             0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  86             0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  87
  88             0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  89             0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  90             0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  91             0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  92             0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  93
  94             0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  95             0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  96             0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  97             0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  98             0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  99
 100             0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 101             0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa
 102         }
 103 #endif /* LTC_TEST_EXT */
 104     };
 105
 106
 107     static const unsigned char hmac_test_case_data[][153] = {
 108         {
 109             "Hi There"
 110         },
 111 #ifdef LTC_TEST_EXT
 112         {
 113             "what do ya want for nothing?"
 114         },
 115         {
 116             0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 117             0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 118             0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 119             0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 120             0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd
 121         },
 122         {
 123             0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 124             0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 125             0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 126             0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 127             0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd
 128         },
 129         {
 130             "Test With Truncation"
 131         },
 132         {
 133             "Test Using Larger Than Block-Size Key - Hash Key First"
 134         },
 135         {
 136             "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data"
 137         },
 138         {
 139             "This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm."
 140         }
 141 #endif /* LTC_TEST_EXT */
 142     };
 143
 144     static const struct hmac_test_case {
 145         const char *num;
 146         const char *algo;
 147         const unsigned char *key;
 148         unsigned long keylen;
 149         const unsigned char *data;
 150         unsigned long datalen;
 151         unsigned char digest[MAXBLOCKSIZE];
 152     } cases[] = {
 153         /*
 154         RFC 2202 3. Test Cases for HMAC-SHA-1
 155         */
 156         { "rfc2202 3.1", "sha1",
 157             hmac_test_case_keys[0], 20,
 158             hmac_test_case_data[0], 8,
 159             {0xb6, 0x17, 0x31, 0x86, 0x55, 0x05, 0x72, 0x64,
 160              0xe2, 0x8b, 0xc0, 0xb6, 0xfb, 0x37, 0x8c, 0x8e,
 161              0xf1, 0x46, 0xbe, 0x00} },
 162
 163 #ifdef LTC_TEST_EXT
 164         { "rfc2202 3.2", "sha1",
 165             hmac_test_case_keys[1], 4,
 166             hmac_test_case_data[1], 28,
 167             {0xef, 0xfc, 0xdf, 0x6a, 0xe5, 0xeb, 0x2f, 0xa2,
 168              0xd2, 0x74, 0x16, 0xd5, 0xf1, 0x84, 0xdf, 0x9c,
 169              0x25, 0x9a, 0x7c, 0x79} },
 170
 171         { "rfc2202 3.3", "sha1",
 172             hmac_test_case_keys[4], 20,
 173             hmac_test_case_data[2], 50,
 174             {0x12, 0x5d, 0x73, 0x42, 0xb9, 0xac, 0x11, 0xcd,
 175              0x91, 0xa3, 0x9a, 0xf4, 0x8a, 0xa1, 0x7b, 0x4f,
 176              0x63, 0xf1, 0x75, 0xd3} },
 177
 178         { "rfc2202 3.4", "sha1",
 179             hmac_test_case_keys[2], 25,
 180             hmac_test_case_data[3], 50,
 181             {0x4c, 0x90, 0x07, 0xf4, 0x02, 0x62, 0x50, 0xc6,
 182              0xbc, 0x84, 0x14, 0xf9, 0xbf, 0x50, 0xc8, 0x6c,
 183              0x2d, 0x72, 0x35, 0xda} },
 184
 185         { "rfc2202 3.5", "sha1",
 186             hmac_test_case_keys[3], 20,
 187             hmac_test_case_data[4], 20,
 188             {0x4c, 0x1a, 0x03, 0x42, 0x4b, 0x55, 0xe0, 0x7f, 0xe7, 0xf2,
 189              0x7b, 0xe1, 0xd5, 0x8b, 0xb9, 0x32, 0x4a, 0x9a, 0x5a, 0x04} },
 190
 191         { "rfc2202 3.6", "sha1",
 192             hmac_test_case_keys[4], 80,
 193             hmac_test_case_data[5], 54,
 194             {0xaa, 0x4a, 0xe5, 0xe1, 0x52, 0x72, 0xd0, 0x0e,
 195              0x95, 0x70, 0x56, 0x37, 0xce, 0x8a, 0x3b, 0x55,
 196              0xed, 0x40, 0x21, 0x12} },
 197
 198         { "rfc2202 3.7", "sha1",
 199             hmac_test_case_keys[4], 80,
 200            hmac_test_case_data[6], 73,
 201             {0xe8, 0xe9, 0x9d, 0x0f, 0x45, 0x23, 0x7d, 0x78, 0x6d,
 202              0x6b, 0xba, 0xa7, 0x96, 0x5c, 0x78, 0x08, 0xbb, 0xff, 0x1a, 0x91} },
 203 #endif /* LTC_TEST_EXT */
 204
 205         /*
 206         RFC 2202 2. Test Cases for HMAC-MD5
 207         */
 208         { "rfc2202 2.1", "md5",
 209             hmac_test_case_keys[0], 16,
 210             hmac_test_case_data[0], 8,
 211             {0x92, 0x94, 0x72, 0x7a, 0x36, 0x38, 0xbb, 0x1c,
 212              0x13, 0xf4, 0x8e, 0xf8, 0x15, 0x8b, 0xfc, 0x9d}  },
 213
 214 #ifdef LTC_TEST_EXT
 215         { "rfc2202 2.2", "md5",
 216             hmac_test_case_keys[1], 4,
 217             hmac_test_case_data[1], 28,
 218             {0x75, 0x0c, 0x78, 0x3e, 0x6a, 0xb0, 0xb5, 0x03,
 219              0xea, 0xa8, 0x6e, 0x31, 0x0a, 0x5d, 0xb7, 0x38} },
 220
 221         { "rfc2202 2.3", "md5",
 222             hmac_test_case_keys[4], 16,
 223             hmac_test_case_data[2], 50,
 224             {0x56, 0xbe, 0x34, 0x52, 0x1d, 0x14, 0x4c, 0x88,
 225              0xdb, 0xb8, 0xc7, 0x33, 0xf0, 0xe8, 0xb3, 0xf6} },
 226
 227         { "rfc2202 2.4", "md5",
 228             hmac_test_case_keys[2], 25,
 229             hmac_test_case_data[3], 50,
 230             {0x69, 0x7e, 0xaf, 0x0a, 0xca, 0x3a, 0x3a, 0xea,
 231              0x3a, 0x75, 0x16, 0x47, 0x46, 0xff, 0xaa, 0x79} },
 232
 233         { "rfc2202 2.5", "md5",
 234             hmac_test_case_keys[3], 16,
 235             hmac_test_case_data[4], 20,
 236             {0x56, 0x46, 0x1e, 0xf2, 0x34, 0x2e, 0xdc, 0x00,
 237              0xf9, 0xba, 0xb9, 0x95, 0x69, 0x0e, 0xfd, 0x4c} },
 238
 239         { "rfc2202 2.6", "md5",
 240             hmac_test_case_keys[4], 80,
 241             hmac_test_case_data[5], 54,
 242             {0x6b, 0x1a, 0xb7, 0xfe, 0x4b, 0xd7, 0xbf, 0x8f,
 243              0x0b, 0x62, 0xe6, 0xce, 0x61, 0xb9, 0xd0, 0xcd} },
 244
 245         { "rfc2202 2.7", "md5",
 246             hmac_test_case_keys[4], 80,
 247            hmac_test_case_data[6], 73,
 248             {0x6f, 0x63, 0x0f, 0xad, 0x67, 0xcd, 0xa0, 0xee,
 249              0x1f, 0xb1, 0xf5, 0x62, 0xdb, 0x3a, 0xa5, 0x3e} },
 250 #endif /* LTC_TEST_EXT */
 251
 252         /*
 253         RFC 2286 2. Test Cases for HMAC-RIPEMD160
 254         */
 255         { "rfc2286 2.1", "rmd160",
 256             hmac_test_case_keys[0], 20,
 257             hmac_test_case_data[0], 8,
 258             {0x24, 0xcb, 0x4b, 0xd6, 0x7d, 0x20, 0xfc, 0x1a,
 259              0x5d, 0x2e, 0xd7, 0x73, 0x2d, 0xcc, 0x39, 0x37,
 260              0x7f, 0x0a, 0x56, 0x68} },
 261
 262 #ifdef LTC_TEST_EXT
 263         { "rfc2286 2.2", "rmd160",
 264             hmac_test_case_keys[1], 4,
 265             hmac_test_case_data[1], 28,
 266             {0xdd, 0xa6, 0xc0, 0x21, 0x3a, 0x48, 0x5a, 0x9e,
 267              0x24, 0xf4, 0x74, 0x20, 0x64, 0xa7, 0xf0, 0x33,
 268              0xb4, 0x3c, 0x40, 0x69} },
 269
 270         { "rfc2286 2.3", "rmd160",
 271             hmac_test_case_keys[4], 20,
 272             hmac_test_case_data[2], 50,
 273             {0xb0, 0xb1, 0x05, 0x36, 0x0d, 0xe7, 0x59, 0x96,
 274              0x0a, 0xb4, 0xf3, 0x52, 0x98, 0xe1, 0x16, 0xe2,
 275              0x95, 0xd8, 0xe7, 0xc1} },
 276
 277         { "rfc2286 2.4", "rmd160",
 278             hmac_test_case_keys[2], 25,
 279             hmac_test_case_data[3], 50,
 280             {0xd5, 0xca, 0x86, 0x2f, 0x4d, 0x21, 0xd5, 0xe6,
 281              0x10, 0xe1, 0x8b, 0x4c, 0xf1, 0xbe, 0xb9, 0x7a,
 282              0x43, 0x65, 0xec, 0xf4} },
 283
 284         { "rfc2286 2.5", "rmd160",
 285             hmac_test_case_keys[3], 20,
 286             hmac_test_case_data[4], 20,
 287             {0x76, 0x19, 0x69, 0x39, 0x78, 0xf9, 0x1d, 0x90,
 288              0x53, 0x9a, 0xe7, 0x86, 0x50, 0x0f, 0xf3, 0xd8,
 289              0xe0, 0x51, 0x8e, 0x39} },
 290
 291         { "rfc2286 2.6", "rmd160",
 292             hmac_test_case_keys[4], 80,
 293             hmac_test_case_data[5], 54,
 294             {0x64, 0x66, 0xca, 0x07, 0xac, 0x5e, 0xac, 0x29,
 295              0xe1, 0xbd, 0x52, 0x3e, 0x5a, 0xda, 0x76, 0x05,
 296              0xb7, 0x91, 0xfd, 0x8b} },
 297
 298         { "rfc2286 2.7", "rmd160",
 299             hmac_test_case_keys[4], 80,
 300             hmac_test_case_data[6], 73,
 301             {0x69, 0xea, 0x60, 0x79, 0x8d, 0x71, 0x61, 0x6c,
 302              0xce, 0x5f, 0xd0, 0x87, 0x1e, 0x23, 0x75, 0x4c,
 303              0xd7, 0x5d, 0x5a, 0x0a} },
 304 #endif /* LTC_TEST_EXT */
 305
 306         /*
 307         RFC 2286 3. Test Cases for HMAC-RIPEMD128
 308         */
 309         { "rfc2286 3.1", "rmd128",
 310             hmac_test_case_keys[0], 16,
 311             hmac_test_case_data[0], 8,
 312             {0xfb, 0xf6, 0x1f, 0x94, 0x92, 0xaa, 0x4b, 0xbf,
 313              0x81, 0xc1, 0x72, 0xe8, 0x4e, 0x07, 0x34, 0xdb} },
 314
 315 #ifdef LTC_TEST_EXT
 316         { "rfc2286 3.2", "rmd128",
 317             hmac_test_case_keys[1], 4,
 318             hmac_test_case_data[1], 28,
 319             {0x87, 0x5f, 0x82, 0x88, 0x62, 0xb6, 0xb3, 0x34,
 320              0xb4, 0x27, 0xc5, 0x5f, 0x9f, 0x7f, 0xf0, 0x9b} },
 321
 322         { "rfc2286 3.3", "rmd128",
 323             hmac_test_case_keys[4], 16,
 324             hmac_test_case_data[2], 50,
 325             {0x09, 0xf0, 0xb2, 0x84, 0x6d, 0x2f, 0x54, 0x3d,
 326              0xa3, 0x63, 0xcb, 0xec, 0x8d, 0x62, 0xa3, 0x8d} },
 327
 328         { "rfc2286 3.4", "rmd128",
 329             hmac_test_case_keys[2], 25,
 330             hmac_test_case_data[3], 50,
 331             {0xbd, 0xbb, 0xd7, 0xcf, 0x03, 0xe4, 0x4b, 0x5a,
 332              0xa6, 0x0a, 0xf8, 0x15, 0xbe, 0x4d, 0x22, 0x94} },
 333
 334         { "rfc2286 3.5", "rmd128",
 335             hmac_test_case_keys[3], 16,
 336             hmac_test_case_data[4], 20,
 337             {0xe7, 0x98, 0x08, 0xf2, 0x4b, 0x25, 0xfd, 0x03,
 338              0x1c, 0x15, 0x5f, 0x0d, 0x55, 0x1d, 0x9a, 0x3a} },
 339
 340         { "rfc2286 3.6", "rmd128",
 341             hmac_test_case_keys[4], 80,
 342             hmac_test_case_data[5], 54,
 343             {0xdc, 0x73, 0x29, 0x28, 0xde, 0x98, 0x10, 0x4a,
 344              0x1f, 0x59, 0xd3, 0x73, 0xc1, 0x50, 0xac, 0xbb} },
 345
 346         { "rfc2286 3.7", "rmd128",
 347             hmac_test_case_keys[4], 80,
 348             hmac_test_case_data[6], 73,
 349             {0x5c, 0x6b, 0xec, 0x96, 0x79, 0x3e, 0x16, 0xd4,
 350              0x06, 0x90, 0xc2, 0x37, 0x63, 0x5f, 0x30, 0xc5} },
 351 #endif /* LTC_TEST_EXT */
 352
 353         /*
 354         RFC 4231 4. Test Vectors
 355         Ch. 4.6 with truncated output left out to simplify tests
 356         */
 357         { "rfc4231 4.2", "sha224",
 358             hmac_test_case_keys[0], 20,
 359             hmac_test_case_data[0], 8,
 360             {0x89, 0x6f, 0xb1, 0x12, 0x8a, 0xbb, 0xdf, 0x19,
 361              0x68, 0x32, 0x10, 0x7c, 0xd4, 0x9d, 0xf3, 0x3f,
 362              0x47, 0xb4, 0xb1, 0x16, 0x99, 0x12, 0xba, 0x4f,
 363              0x53, 0x68, 0x4b, 0x22} },
 364
 365 #ifdef LTC_TEST_EXT
 366         { "rfc4231 4.3", "sha224",
 367             hmac_test_case_keys[1], 4,
 368             hmac_test_case_data[1], 28,
 369             {0xa3, 0x0e, 0x01, 0x09, 0x8b, 0xc6, 0xdb, 0xbf,
 370              0x45, 0x69, 0x0f, 0x3a, 0x7e, 0x9e, 0x6d, 0x0f,
 371              0x8b, 0xbe, 0xa2, 0xa3, 0x9e, 0x61, 0x48, 0x00,
 372              0x8f, 0xd0, 0x5e, 0x44} },
 373
 374         { "rfc4231 4.4", "sha224",
 375             hmac_test_case_keys[4], 20,
 376             hmac_test_case_data[2], 50,
 377             {0x7f, 0xb3, 0xcb, 0x35, 0x88, 0xc6, 0xc1, 0xf6,
 378              0xff, 0xa9, 0x69, 0x4d, 0x7d, 0x6a, 0xd2, 0x64,
 379              0x93, 0x65, 0xb0, 0xc1, 0xf6, 0x5d, 0x69, 0xd1,
 380              0xec, 0x83, 0x33, 0xea} },
 381
 382         { "rfc4231 4.5", "sha224",
 383             hmac_test_case_keys[2], 25,
 384             hmac_test_case_data[3], 50,
 385             {0x6c, 0x11, 0x50, 0x68, 0x74, 0x01, 0x3c, 0xac,
 386              0x6a, 0x2a, 0xbc, 0x1b, 0xb3, 0x82, 0x62, 0x7c,
 387              0xec, 0x6a, 0x90, 0xd8, 0x6e, 0xfc, 0x01, 0x2d,
 388              0xe7, 0xaf, 0xec, 0x5a} },
 389
 390         { "rfc4231 4.7", "sha224",
 391             hmac_test_case_keys[4], 131,
 392             hmac_test_case_data[5], 54,
 393             {0x95, 0xe9, 0xa0, 0xdb, 0x96, 0x20, 0x95, 0xad,
 394              0xae, 0xbe, 0x9b, 0x2d, 0x6f, 0x0d, 0xbc, 0xe2,
 395              0xd4, 0x99, 0xf1, 0x12, 0xf2, 0xd2, 0xb7, 0x27,
 396              0x3f, 0xa6, 0x87, 0x0e} },
 397
 398         { "rfc4231 4.8", "sha224",
 399             hmac_test_case_keys[4], 131,
 400             hmac_test_case_data[7], 152,
 401             {0x3a, 0x85, 0x41, 0x66, 0xac, 0x5d, 0x9f, 0x02,
 402              0x3f, 0x54, 0xd5, 0x17, 0xd0, 0xb3, 0x9d, 0xbd,
 403              0x94, 0x67, 0x70, 0xdb, 0x9c, 0x2b, 0x95, 0xc9,
 404              0xf6, 0xf5, 0x65, 0xd1} },
 405 #endif /* LTC_TEST_EXT */
 406
 407         { "rfc4231 4.2", "sha256",
 408             hmac_test_case_keys[0], 20,
 409             hmac_test_case_data[0], 8,
 410             {0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53,
 411              0x5c, 0xa8, 0xaf, 0xce, 0xaf, 0x0b, 0xf1, 0x2b,
 412              0x88, 0x1d, 0xc2, 0x00, 0xc9, 0x83, 0x3d, 0xa7,
 413              0x26, 0xe9, 0x37, 0x6c, 0x2e, 0x32, 0xcf, 0xf7} },
 414
 415 #ifdef LTC_TEST_EXT
 416         { "rfc4231 4.3", "sha256",
 417             hmac_test_case_keys[1], 4,
 418             hmac_test_case_data[1], 28,
 419             {0x5b, 0xdc, 0xc1, 0x46, 0xbf, 0x60, 0x75, 0x4e,
 420              0x6a, 0x04, 0x24, 0x26, 0x08, 0x95, 0x75, 0xc7,
 421              0x5a, 0x00, 0x3f, 0x08, 0x9d, 0x27, 0x39, 0x83,
 422              0x9d, 0xec, 0x58, 0xb9, 0x64, 0xec, 0x38, 0x43} },
 423
 424         { "rfc4231 4.4", "sha256",
 425             hmac_test_case_keys[4], 20,
 426             hmac_test_case_data[2], 50,
 427             {0x77, 0x3e, 0xa9, 0x1e, 0x36, 0x80, 0x0e, 0x46,
 428              0x85, 0x4d, 0xb8, 0xeb, 0xd0, 0x91, 0x81, 0xa7,
 429              0x29, 0x59, 0x09, 0x8b, 0x3e, 0xf8, 0xc1, 0x22,
 430              0xd9, 0x63, 0x55, 0x14, 0xce, 0xd5, 0x65, 0xfe} },
 431
 432         { "rfc4231 4.5", "sha256",
 433             hmac_test_case_keys[2], 25,
 434             hmac_test_case_data[3], 50,
 435             {0x82, 0x55, 0x8a, 0x38, 0x9a, 0x44, 0x3c, 0x0e,
 436              0xa4, 0xcc, 0x81, 0x98, 0x99, 0xf2, 0x08, 0x3a,
 437              0x85, 0xf0, 0xfa, 0xa3, 0xe5, 0x78, 0xf8, 0x07,
 438              0x7a, 0x2e, 0x3f, 0xf4, 0x67, 0x29, 0x66, 0x5b} },
 439
 440         { "rfc4231 4.7", "sha256",
 441             hmac_test_case_keys[4], 131,
 442             hmac_test_case_data[5], 54,
 443             {0x60, 0xe4, 0x31, 0x59, 0x1e, 0xe0, 0xb6, 0x7f,
 444              0x0d, 0x8a, 0x26, 0xaa, 0xcb, 0xf5, 0xb7, 0x7f,
 445              0x8e, 0x0b, 0xc6, 0x21, 0x37, 0x28, 0xc5, 0x14,
 446              0x05, 0x46, 0x04, 0x0f, 0x0e, 0xe3, 0x7f, 0x54} },
 447
 448         { "rfc4231 4.8", "sha256",
 449             hmac_test_case_keys[4], 131,
 450             hmac_test_case_data[7], 152,
 451             {0x9b, 0x09, 0xff, 0xa7, 0x1b, 0x94, 0x2f, 0xcb,
 452              0x27, 0x63, 0x5f, 0xbc, 0xd5, 0xb0, 0xe9, 0x44,
 453              0xbf, 0xdc, 0x63, 0x64, 0x4f, 0x07, 0x13, 0x93,
 454              0x8a, 0x7f, 0x51, 0x53, 0x5c, 0x3a, 0x35, 0xe2} },
 455 #endif /* LTC_TEST_EXT */
 456
 457         { "rfc4231 4.2", "sha384",
 458             hmac_test_case_keys[0], 20,
 459             hmac_test_case_data[0], 8,
 460             {0xaf, 0xd0, 0x39, 0x44, 0xd8, 0x48, 0x95, 0x62,
 461              0x6b, 0x08, 0x25, 0xf4, 0xab, 0x46, 0x90, 0x7f,
 462              0x15, 0xf9, 0xda, 0xdb, 0xe4, 0x10, 0x1e, 0xc6,
 463              0x82, 0xaa, 0x03, 0x4c, 0x7c, 0xeb, 0xc5, 0x9c,
 464              0xfa, 0xea, 0x9e, 0xa9, 0x07, 0x6e, 0xde, 0x7f,
 465              0x4a, 0xf1, 0x52, 0xe8, 0xb2, 0xfa, 0x9c, 0xb6} },
 466
 467 #ifdef LTC_TEST_EXT
 468         { "rfc4231 4.3", "sha384",
 469             hmac_test_case_keys[1], 4,
 470             hmac_test_case_data[1], 28,
 471             {0xaf, 0x45, 0xd2, 0xe3, 0x76, 0x48, 0x40, 0x31,
 472              0x61, 0x7f, 0x78, 0xd2, 0xb5, 0x8a, 0x6b, 0x1b,
 473              0x9c, 0x7e, 0xf4, 0x64, 0xf5, 0xa0, 0x1b, 0x47,
 474              0xe4, 0x2e, 0xc3, 0x73, 0x63, 0x22, 0x44, 0x5e,
 475              0x8e, 0x22, 0x40, 0xca, 0x5e, 0x69, 0xe2, 0xc7,
 476              0x8b, 0x32, 0x39, 0xec, 0xfa, 0xb2, 0x16, 0x49} },
 477
 478         { "rfc4231 4.4", "sha384",
 479             hmac_test_case_keys[4], 20,
 480             hmac_test_case_data[2], 50,
 481             {0x88, 0x06, 0x26, 0x08, 0xd3, 0xe6, 0xad, 0x8a,
 482              0x0a, 0xa2, 0xac, 0xe0, 0x14, 0xc8, 0xa8, 0x6f,
 483              0x0a, 0xa6, 0x35, 0xd9, 0x47, 0xac, 0x9f, 0xeb,
 484              0xe8, 0x3e, 0xf4, 0xe5, 0x59, 0x66, 0x14, 0x4b,
 485              0x2a, 0x5a, 0xb3, 0x9d, 0xc1, 0x38, 0x14, 0xb9,
 486              0x4e, 0x3a, 0xb6, 0xe1, 0x01, 0xa3, 0x4f, 0x27} },
 487
 488         { "rfc4231 4.5", "sha384",
 489             hmac_test_case_keys[2], 25,
 490             hmac_test_case_data[3], 50,
 491             {0x3e, 0x8a, 0x69, 0xb7, 0x78, 0x3c, 0x25, 0x85,
 492              0x19, 0x33, 0xab, 0x62, 0x90, 0xaf, 0x6c, 0xa7,
 493              0x7a, 0x99, 0x81, 0x48, 0x08, 0x50, 0x00, 0x9c,
 494              0xc5, 0x57, 0x7c, 0x6e, 0x1f, 0x57, 0x3b, 0x4e,
 495              0x68, 0x01, 0xdd, 0x23, 0xc4, 0xa7, 0xd6, 0x79,
 496              0xcc, 0xf8, 0xa3, 0x86, 0xc6, 0x74, 0xcf, 0xfb} },
 497
 498         { "rfc4231 4.7", "sha384",
 499             hmac_test_case_keys[4], 131,
 500             hmac_test_case_data[5], 54,
 501             {0x4e, 0xce, 0x08, 0x44, 0x85, 0x81, 0x3e, 0x90,
 502              0x88, 0xd2, 0xc6, 0x3a, 0x04, 0x1b, 0xc5, 0xb4,
 503              0x4f, 0x9e, 0xf1, 0x01, 0x2a, 0x2b, 0x58, 0x8f,
 504              0x3c, 0xd1, 0x1f, 0x05, 0x03, 0x3a, 0xc4, 0xc6,
 505              0x0c, 0x2e, 0xf6, 0xab, 0x40, 0x30, 0xfe, 0x82,
 506              0x96, 0x24, 0x8d, 0xf1, 0x63, 0xf4, 0x49, 0x52} },
 507
 508         { "rfc4231 4.8", "sha384",
 509             hmac_test_case_keys[4], 131,
 510             hmac_test_case_data[7], 152,
 511             {0x66, 0x17, 0x17, 0x8e, 0x94, 0x1f, 0x02, 0x0d,
 512              0x35, 0x1e, 0x2f, 0x25, 0x4e, 0x8f, 0xd3, 0x2c,
 513              0x60, 0x24, 0x20, 0xfe, 0xb0, 0xb8, 0xfb, 0x9a,
 514              0xdc, 0xce, 0xbb, 0x82, 0x46, 0x1e, 0x99, 0xc5,
 515              0xa6, 0x78, 0xcc, 0x31, 0xe7, 0x99, 0x17, 0x6d,
 516              0x38, 0x60, 0xe6, 0x11, 0x0c, 0x46, 0x52, 0x3e} },
 517 #endif /* LTC_TEST_EXT */
 518
 519         { "rfc4231 4.2", "sha512",
 520             hmac_test_case_keys[0], 20,
 521             hmac_test_case_data[0], 8,
 522             {0x87, 0xaa, 0x7c, 0xde, 0xa5, 0xef, 0x61, 0x9d,
 523              0x4f, 0xf0, 0xb4, 0x24, 0x1a, 0x1d, 0x6c, 0xb0,
 524              0x23, 0x79, 0xf4, 0xe2, 0xce, 0x4e, 0xc2, 0x78,
 525              0x7a, 0xd0, 0xb3, 0x05, 0x45, 0xe1, 0x7c, 0xde,
 526              0xda, 0xa8, 0x33, 0xb7, 0xd6, 0xb8, 0xa7, 0x02,
 527              0x03, 0x8b, 0x27, 0x4e, 0xae, 0xa3, 0xf4, 0xe4,
 528              0xbe, 0x9d, 0x91, 0x4e, 0xeb, 0x61, 0xf1, 0x70,
 529              0x2e, 0x69, 0x6c, 0x20, 0x3a, 0x12, 0x68, 0x54} },
 530
 531 #ifdef LTC_TEST_EXT
 532         { "rfc4231 4.3", "sha512",
 533             hmac_test_case_keys[1], 4,
 534             hmac_test_case_data[1], 28,
 535             {0x16, 0x4b, 0x7a, 0x7b, 0xfc, 0xf8, 0x19, 0xe2,
 536              0xe3, 0x95, 0xfb, 0xe7, 0x3b, 0x56, 0xe0, 0xa3,
 537              0x87, 0xbd, 0x64, 0x22, 0x2e, 0x83, 0x1f, 0xd6,
 538              0x10, 0x27, 0x0c, 0xd7, 0xea, 0x25, 0x05, 0x54,
 539              0x97, 0x58, 0xbf, 0x75, 0xc0, 0x5a, 0x99, 0x4a,
 540              0x6d, 0x03, 0x4f, 0x65, 0xf8, 0xf0, 0xe6, 0xfd,
 541              0xca, 0xea, 0xb1, 0xa3, 0x4d, 0x4a, 0x6b, 0x4b,
 542              0x63, 0x6e, 0x07, 0x0a, 0x38, 0xbc, 0xe7, 0x37} },
 543
 544         { "rfc4231 4.4", "sha512",
 545             hmac_test_case_keys[4], 20,
 546             hmac_test_case_data[2], 50,
 547             {0xfa, 0x73, 0xb0, 0x08, 0x9d, 0x56, 0xa2, 0x84,
 548              0xef, 0xb0, 0xf0, 0x75, 0x6c, 0x89, 0x0b, 0xe9,
 549              0xb1, 0xb5, 0xdb, 0xdd, 0x8e, 0xe8, 0x1a, 0x36,
 550              0x55, 0xf8, 0x3e, 0x33, 0xb2, 0x27, 0x9d, 0x39,
 551              0xbf, 0x3e, 0x84, 0x82, 0x79, 0xa7, 0x22, 0xc8,
 552              0x06, 0xb4, 0x85, 0xa4, 0x7e, 0x67, 0xc8, 0x07,
 553              0xb9, 0x46, 0xa3, 0x37, 0xbe, 0xe8, 0x94, 0x26,
 554              0x74, 0x27, 0x88, 0x59, 0xe1, 0x32, 0x92, 0xfb} },
 555
 556         { "rfc4231 4.5", "sha512",
 557             hmac_test_case_keys[2], 25,
 558             hmac_test_case_data[3], 50,
 559             {0xb0, 0xba, 0x46, 0x56, 0x37, 0x45, 0x8c, 0x69,
 560              0x90, 0xe5, 0xa8, 0xc5, 0xf6, 0x1d, 0x4a, 0xf7,
 561              0xe5, 0x76, 0xd9, 0x7f, 0xf9, 0x4b, 0x87, 0x2d,
 562              0xe7, 0x6f, 0x80, 0x50, 0x36, 0x1e, 0xe3, 0xdb,
 563              0xa9, 0x1c, 0xa5, 0xc1, 0x1a, 0xa2, 0x5e, 0xb4,
 564              0xd6, 0x79, 0x27, 0x5c, 0xc5, 0x78, 0x80, 0x63,
 565              0xa5, 0xf1, 0x97, 0x41, 0x12, 0x0c, 0x4f, 0x2d,
 566              0xe2, 0xad, 0xeb, 0xeb, 0x10, 0xa2, 0x98, 0xdd} },
 567
 568         { "rfc4231 4.7", "sha512",
 569             hmac_test_case_keys[4], 131,
 570             hmac_test_case_data[5], 54,
 571             {0x80, 0xb2, 0x42, 0x63, 0xc7, 0xc1, 0xa3, 0xeb,
 572              0xb7, 0x14, 0x93, 0xc1, 0xdd, 0x7b, 0xe8, 0xb4,
 573              0x9b, 0x46, 0xd1, 0xf4, 0x1b, 0x4a, 0xee, 0xc1,
 574              0x12, 0x1b, 0x01, 0x37, 0x83, 0xf8, 0xf3, 0x52,
 575              0x6b, 0x56, 0xd0, 0x37, 0xe0, 0x5f, 0x25, 0x98,
 576              0xbd, 0x0f, 0xd2, 0x21, 0x5d, 0x6a, 0x1e, 0x52,
 577              0x95, 0xe6, 0x4f, 0x73, 0xf6, 0x3f, 0x0a, 0xec,
 578              0x8b, 0x91, 0x5a, 0x98, 0x5d, 0x78, 0x65, 0x98} },
 579
 580         { "rfc4231 4.8", "sha512",
 581             hmac_test_case_keys[4], 131,
 582             hmac_test_case_data[7], 152,
 583             {0xe3, 0x7b, 0x6a, 0x77, 0x5d, 0xc8, 0x7d, 0xba,
 584              0xa4, 0xdf, 0xa9, 0xf9, 0x6e, 0x5e, 0x3f, 0xfd,
 585              0xde, 0xbd, 0x71, 0xf8, 0x86, 0x72, 0x89, 0x86,
 586              0x5d, 0xf5, 0xa3, 0x2d, 0x20, 0xcd, 0xc9, 0x44,
 587              0xb6, 0x02, 0x2c, 0xac, 0x3c, 0x49, 0x82, 0xb1,
 588              0x0d, 0x5e, 0xeb, 0x55, 0xc3, 0xe4, 0xde, 0x15,
 589              0x13, 0x46, 0x76, 0xfb, 0x6d, 0xe0, 0x44, 0x60,
 590              0x65, 0xc9, 0x74, 0x40, 0xfa, 0x8c, 0x6a, 0x58} },
 591 #endif /* LTC_TEST_EXT */
 592
 593     };
 594
 595     unsigned long outlen;
 596     int err;
 597     int tested=0,failed=0;
 598     for(i=0; i < (int)(sizeof(cases) / sizeof(cases[0])); i++) {
 599         int hash = find_hash(cases[i].algo);
 600         if (hash == -1) continue;
 601         ++tested;
 602         outlen = sizeof(digest);
 603         if((err = hmac_memory(hash, cases[i].key, cases[i].keylen, cases[i].data, cases[i].datalen, digest, &outlen)) != CRYPT_OK) {
 604 #ifdef LTC_TEST_DBG
 605             printf("HMAC-%s test %s, %s\n", cases[i].algo, cases[i].num, error_to_string(err));
 606 #endif
 607             return err;
 608         }
 609
 610         if(compare_testvector(digest, outlen, cases[i].digest, (size_t)hash_descriptor[hash].hashsize, cases[i].num, i)) {
 611             failed++;
 612         }
 613     }
 614
 615     if (failed != 0) {
 616         return CRYPT_FAIL_TESTVECTOR;
 617     } else if (tested == 0) {
 618         return CRYPT_NOP;
 619     } else {
 620         return CRYPT_OK;
 621     }
 622  #endif
 623 }
 624
 625 #endif
 626
 627
 628 /* ref:         $Format:%D$ */
 629 /* git commit:  $Format:%H$ */
 630 /* commit time: $Format:%ai$ */