test/test/test_cryptodev_hash_test_vectors.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2016-2017 Intel Corporation
   3  */
   4
   5 #ifndef TEST_CRYPTODEV_HASH_TEST_VECTORS_H_
   6 #define TEST_CRYPTODEV_HASH_TEST_VECTORS_H_
   7
   8 #ifdef RTE_LIBRTE_PMD_AESNI_MB
   9 #include <intel-ipsec-mb.h>
  10 #endif
  11
  12 #if !defined(IMB_VERSION_NUM)
  13 #define IMB_VERSION(a, b, c) (((a) << 16) + ((b) << 8) + (c))
  14 #define IMB_VERSION_NUM IMB_VERSION(0, 49, 0)
  15 #endif
  16
  17 static const uint8_t plaintext_hash[] = {
  18         "What a lousy earth! He wondered how many people "
  19         "were destitute that same night even in his own "
  20         "prosperous country, how many homes were "
  21         "shanties, how many husbands were drunk and "
  22         "wives socked, and how many children were "
  23         "bullied, abused, or abandoned. How many "
  24         "families hungered for food they could not "
  25         "afford to buy? How many hearts were broken? How "
  26         "many suicides would take place that same night, "
  27         "how many people would go insane? How many "
  28         "cockroaches and landlords would triumph? How "
  29         "many winners were losers, successes failures, "
  30         "and rich men poor men? How many wise guys were "
  31         "stupid? How many happy endings were unhappy "
  32         "endings? How many honest men were liars, brave "
  33         "men cowards, loyal men traitors, how many "
  34         "sainted men were corrupt, how many people in "
  35         "positions of trust had sold their souls to "
  36         "bodyguards, how many had never had souls? How "
  37         "many straight-and-narrow paths were crooked "
  38         "paths? How many best families were worst "
  39         "families and how many good people were bad "
  40         "people? When you added them all up and then "
  41         "subtracted, you might be left with only the "
  42         "children, and perhaps with Albert Einstein and "
  43         "an old violinist or sculptor somewhere."
  44 };
  45
  46 static const struct blockcipher_test_data
  47 md5_test_vector = {
  48         .auth_algo = RTE_CRYPTO_AUTH_MD5,
  49         .ciphertext = {
  50                 .data = plaintext_hash,
  51                 .len = 512
  52         },
  53         .digest = {
  54                 .data = {
  55                         0xB3, 0xE6, 0xBB, 0x50, 0x41, 0x35, 0x3C, 0x6B,
  56                         0x7A, 0xFF, 0xD2, 0x64, 0xAF, 0xD5, 0x1C, 0xB2
  57                 },
  58                 .len = 16
  59         }
  60 };
  61
  62 static const struct blockcipher_test_data
  63 hmac_md5_test_vector = {
  64         .auth_algo = RTE_CRYPTO_AUTH_MD5_HMAC,
  65         .ciphertext = {
  66                 .data = plaintext_hash,
  67                 .len = 512
  68         },
  69         .auth_key = {
  70                 .data = {
  71                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
  72                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD
  73                 },
  74                 .len = 16
  75         },
  76         .digest = {
  77                 .data = {
  78                         0x50, 0xE8, 0xDE, 0xC5, 0xC1, 0x76, 0xAC, 0xAE,
  79                         0x15, 0x4A, 0xF1, 0x7F, 0x7E, 0x04, 0x42, 0x9B
  80                 },
  81                 .len = 16,
  82                 .truncated_len = 12
  83         }
  84 };
  85
  86 static const struct blockcipher_test_data
  87 sha1_test_vector = {
  88         .auth_algo = RTE_CRYPTO_AUTH_SHA1,
  89         .ciphertext = {
  90                 .data = plaintext_hash,
  91                 .len = 512
  92         },
  93         .digest = {
  94                 .data = {
  95                         0xA2, 0x8D, 0x40, 0x78, 0xDD, 0x9F, 0xBB, 0xD5,
  96                         0x35, 0x62, 0xFB, 0xFA, 0x93, 0xFD, 0x7D, 0x70,
  97                         0xA6, 0x7D, 0x45, 0xCA
  98                 },
  99                 .len = 20
 100         }
 101 };
 102
 103 static const struct blockcipher_test_data
 104 hmac_sha1_test_vector = {
 105         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
 106         .ciphertext = {
 107                 .data = plaintext_hash,
 108                 .len = 512
 109         },
 110         .auth_key = {
 111                 .data = {
 112                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 113                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 114                         0xDE, 0xF4, 0xDE, 0xAD
 115                 },
 116                 .len = 20
 117         },
 118         .digest = {
 119                 .data = {
 120                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
 121                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
 122                         0x3F, 0x91, 0x64, 0x59
 123                 },
 124                 .len = 20,
 125                 .truncated_len = 12
 126         }
 127 };
 128
 129 static const struct blockcipher_test_data
 130 sha224_test_vector = {
 131         .auth_algo = RTE_CRYPTO_AUTH_SHA224,
 132         .ciphertext = {
 133                 .data = plaintext_hash,
 134                 .len = 512
 135         },
 136         .digest = {
 137                 .data = {
 138                         0x91, 0xE7, 0xCD, 0x75, 0x14, 0x9C, 0xA9, 0xE9,
 139                         0x2E, 0x46, 0x12, 0x20, 0x22, 0xF9, 0x68, 0x28,
 140                         0x39, 0x26, 0xDF, 0xB5, 0x78, 0x62, 0xB2, 0x6E,
 141                         0x5E, 0x8F, 0x25, 0x84
 142                 },
 143                 .len = 28
 144         }
 145 };
 146
 147 static const struct blockcipher_test_data
 148 hmac_sha224_test_vector = {
 149         .auth_algo = RTE_CRYPTO_AUTH_SHA224_HMAC,
 150         .ciphertext = {
 151                 .data = plaintext_hash,
 152                 .len = 512
 153         },
 154         .auth_key = {
 155                 .data = {
 156                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 157                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 158                         0xDE, 0xF4, 0xDE, 0xAD, 0x26, 0xEB, 0xAB, 0x92,
 159                         0xFB, 0xBF, 0xB0, 0x8C
 160                 },
 161                 .len = 28
 162         },
 163         .digest = {
 164                 .data = {
 165                         0x70, 0x0F, 0x04, 0x4D, 0x22, 0x02, 0x7D, 0x31,
 166                         0x36, 0xDA, 0x77, 0x19, 0xB9, 0x66, 0x37, 0x7B,
 167                         0xF1, 0x8A, 0x63, 0xBB, 0x5D, 0x1D, 0xE3, 0x9F,
 168                         0x92, 0xF6, 0xAA, 0x19
 169                 },
 170                 .len = 28,
 171                 .truncated_len = 14
 172         }
 173 };
 174
 175 static const struct blockcipher_test_data
 176 sha256_test_vector = {
 177         .auth_algo = RTE_CRYPTO_AUTH_SHA256,
 178         .ciphertext = {
 179                 .data = plaintext_hash,
 180                 .len = 512
 181         },
 182         .digest = {
 183                 .data = {
 184                         0x7F, 0xF1, 0x0C, 0xF5, 0x90, 0x97, 0x19, 0x0F,
 185                         0x00, 0xE4, 0x83, 0x01, 0xCA, 0x59, 0x00, 0x2E,
 186                         0x1F, 0xC7, 0x84, 0xEE, 0x76, 0xA6, 0x39, 0x15,
 187                         0x76, 0x2F, 0x87, 0xF9, 0x01, 0x06, 0xF3, 0xB7
 188                 },
 189                 .len = 32
 190         }
 191 };
 192
 193 static const struct blockcipher_test_data
 194 hmac_sha256_test_vector = {
 195         .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC,
 196         .ciphertext = {
 197                 .data = plaintext_hash,
 198                 .len = 512
 199         },
 200         .auth_key = {
 201                 .data = {
 202                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 203                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 204                         0xDE, 0xF4, 0xDE, 0xAD, 0x26, 0xEB, 0xAB, 0x92,
 205                         0xFB, 0xBF, 0xB0, 0x8C, 0x29, 0x87, 0x90, 0xAC
 206                 },
 207                 .len = 32
 208         },
 209         .digest = {
 210                 .data = {
 211                         0xAF, 0x8F, 0x70, 0x1B, 0x4B, 0xAF, 0x34, 0xCB,
 212                         0x02, 0x24, 0x48, 0x45, 0x83, 0x52, 0x8F, 0x22,
 213                         0x06, 0x4D, 0x64, 0x09, 0x0A, 0xCC, 0x02, 0x77,
 214                         0x71, 0x83, 0x48, 0x71, 0x07, 0x02, 0x25, 0x17
 215                 },
 216                 .len = 32,
 217                 .truncated_len = 16
 218         }
 219 };
 220
 221 static const struct blockcipher_test_data
 222 sha384_test_vector = {
 223         .auth_algo = RTE_CRYPTO_AUTH_SHA384,
 224         .ciphertext = {
 225                 .data = plaintext_hash,
 226                 .len = 512
 227         },
 228         .digest = {
 229                 .data = {
 230                         0x1D, 0xE7, 0x3F, 0x55, 0x86, 0xFE, 0x48, 0x9F,
 231                         0xAC, 0xC6, 0x85, 0x32, 0xFA, 0x8E, 0xA6, 0x77,
 232                         0x25, 0x84, 0xA5, 0x98, 0x8D, 0x0B, 0x80, 0xF4,
 233                         0xEB, 0x2C, 0xFB, 0x6C, 0xEA, 0x7B, 0xFD, 0xD5,
 234                         0xAD, 0x41, 0xAB, 0x15, 0xB0, 0x03, 0x15, 0xEC,
 235                         0x9E, 0x3D, 0xED, 0xCB, 0x80, 0x7B, 0xF4, 0xB6
 236                 },
 237                 .len = 48
 238         }
 239 };
 240
 241 static const struct blockcipher_test_data
 242 hmac_sha384_test_vector = {
 243         .auth_algo = RTE_CRYPTO_AUTH_SHA384_HMAC,
 244         .ciphertext = {
 245                 .data = plaintext_hash,
 246                 .len = 512
 247         },
 248         .auth_key = {
 249                 .data = {
 250                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 251                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 252                         0xDE, 0xF4, 0xDE, 0xAD, 0x26, 0xEB, 0xAB, 0x92,
 253                         0xFB, 0xBF, 0xB0, 0x8C, 0x29, 0x87, 0x90, 0xAC,
 254                         0x39, 0x8B, 0x5C, 0x49, 0x68, 0x1E, 0x3A, 0x05,
 255                         0xCC, 0x68, 0x5C, 0x76, 0xCB, 0x3C, 0x71, 0x89
 256                 },
 257                 .len = 48
 258         },
 259         .digest = {
 260                 .data = {
 261                         0xE2, 0x83, 0x18, 0x55, 0xB5, 0x8D, 0x94, 0x9B,
 262                         0x01, 0xB6, 0xE2, 0x57, 0x7A, 0x62, 0xF5, 0xF4,
 263                         0xAB, 0x39, 0xF3, 0x3C, 0x28, 0xA0, 0x0F, 0xCC,
 264                         0xEE, 0x1C, 0xF1, 0xF8, 0x69, 0xF1, 0x24, 0x3B,
 265                         0x10, 0x90, 0x0A, 0xE3, 0xF0, 0x59, 0xDD, 0xC0,
 266                         0x6F, 0xE6, 0x8C, 0x84, 0xD5, 0x03, 0xF8, 0x9E
 267                 },
 268                 .len = 48,
 269                 .truncated_len = 24
 270         }
 271 };
 272
 273 static const struct blockcipher_test_data
 274 sha512_test_vector = {
 275         .auth_algo = RTE_CRYPTO_AUTH_SHA512,
 276         .ciphertext = {
 277                 .data = plaintext_hash,
 278                 .len = 512
 279         },
 280         .digest = {
 281                 .data = {
 282                         0xB9, 0xBA, 0x28, 0x48, 0x3C, 0xC2, 0xD3, 0x65,
 283                         0x4A, 0xD6, 0x00, 0x1D, 0xCE, 0x61, 0x64, 0x54,
 284                         0x45, 0x8C, 0x64, 0x0E, 0xED, 0x0E, 0xD8, 0x1C,
 285                         0x72, 0xCE, 0xD2, 0x44, 0x91, 0xC8, 0xEB, 0xC7,
 286                         0x99, 0xC5, 0xCA, 0x89, 0x72, 0x64, 0x96, 0x41,
 287                         0xC8, 0xEA, 0xB2, 0x4E, 0xD1, 0x21, 0x13, 0x49,
 288                         0x64, 0x4E, 0x15, 0x68, 0x12, 0x67, 0x26, 0x0F,
 289                         0x2C, 0x3C, 0x83, 0x25, 0x27, 0x86, 0xF0, 0xDB
 290                 },
 291                 .len = 64
 292         }
 293 };
 294
 295 static const struct blockcipher_test_data
 296 hmac_sha512_test_vector = {
 297         .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC,
 298         .ciphertext = {
 299                 .data = plaintext_hash,
 300                 .len = 512
 301         },
 302         .auth_key = {
 303                 .data = {
 304                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 305                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 306                         0xDE, 0xF4, 0xDE, 0xAD, 0x26, 0xEB, 0xAB, 0x92,
 307                         0xFB, 0xBF, 0xB0, 0x8C, 0x29, 0x87, 0x90, 0xAC,
 308                         0x39, 0x8B, 0x5C, 0x49, 0x68, 0x1E, 0x3A, 0x05,
 309                         0xCC, 0x68, 0x5C, 0x76, 0xCB, 0x3C, 0x71, 0x89,
 310                         0xDE, 0xAA, 0x36, 0x44, 0x98, 0x93, 0x97, 0x1E,
 311                         0x6D, 0x53, 0x83, 0x87, 0xB3, 0xB7, 0x56, 0x41
 312                 },
 313                 .len = 64
 314         },
 315         .digest = {
 316                 .data = {
 317                         0xB8, 0x0B, 0x35, 0x97, 0x3F, 0x24, 0x3F, 0x05,
 318                         0x2A, 0x7F, 0x2F, 0xD8, 0xD7, 0x56, 0x58, 0xAD,
 319                         0x6F, 0x8D, 0x1F, 0x4C, 0x30, 0xF9, 0xA8, 0x29,
 320                         0x7A, 0xE0, 0x8D, 0x88, 0xF5, 0x2E, 0x94, 0xF5,
 321                         0x06, 0xF7, 0x5D, 0x57, 0x32, 0xA8, 0x49, 0x29,
 322                         0xEA, 0x6B, 0x6D, 0x95, 0xBD, 0x76, 0xF5, 0x79,
 323                         0x97, 0x37, 0x0F, 0xBE, 0xC2, 0x45, 0xA0, 0x87,
 324                         0xAF, 0x24, 0x27, 0x0C, 0x78, 0xBA, 0xBE, 0x20
 325                 },
 326                 .len = 64,
 327                 .truncated_len = 32
 328         }
 329 };
 330
 331 static const struct blockcipher_test_data
 332 cmac_test_vector = {
 333         .auth_algo = RTE_CRYPTO_AUTH_AES_CMAC,
 334         .ciphertext = {
 335                 .data = plaintext_hash,
 336                 .len = 512
 337         },
 338         .auth_key = {
 339                 .data = {
 340                         0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
 341                         0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
 342                 },
 343                 .len = 16
 344         },
 345         .digest = {
 346                 .data = {
 347                         0x4C, 0x77, 0x87, 0xA0, 0x78, 0x8E, 0xEA, 0x96,
 348                         0xC1, 0xEB, 0x1E, 0x4E, 0x95, 0x8F, 0xED, 0x27
 349                 },
 350                 .len = 16,
 351                 .truncated_len = 16
 352         }
 353 };
 354
 355 static const struct blockcipher_test_data
 356 cmac_test_vector_12 = {
 357         .auth_algo = RTE_CRYPTO_AUTH_AES_CMAC,
 358         .ciphertext = {
 359                 .data = plaintext_hash,
 360                 .len = 512
 361         },
 362         .auth_key = {
 363                 .data = {
 364                         0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
 365                         0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
 366                 },
 367                 .len = 16
 368         },
 369         .digest = {
 370                 .data = {
 371                         0x4C, 0x77, 0x87, 0xA0, 0x78, 0x8E, 0xEA, 0x96,
 372                         0xC1, 0xEB, 0x1E, 0x4E, 0x95, 0x8F, 0xED, 0x27
 373                 },
 374                 .len = 12,
 375                 .truncated_len = 12
 376         }
 377 };
 378
 379 static const struct blockcipher_test_case hash_test_cases[] = {
 380         {
 381                 .test_descr = "MD5 Digest",
 382                 .test_data = &md5_test_vector,
 383                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 384                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 385                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 386                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 387         },
 388         {
 389                 .test_descr = "MD5 Digest Verify",
 390                 .test_data = &md5_test_vector,
 391                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 392                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 393                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 394                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 395         },
 396         {
 397                 .test_descr = "HMAC-MD5 Digest",
 398                 .test_data = &hmac_md5_test_vector,
 399                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 400                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 401                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 402                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 403                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 404                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 405                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 406                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 407                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 408                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 409         },
 410         {
 411                 .test_descr = "HMAC-MD5 Digest Verify",
 412                 .test_data = &hmac_md5_test_vector,
 413                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 414                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 415                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 416                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 417                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 418                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 419                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 420                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 421                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 422                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 423         },
 424         {
 425                 .test_descr = "SHA1 Digest",
 426                 .test_data = &sha1_test_vector,
 427                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 428                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 429                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 430                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 431                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 432         },
 433         {
 434                 .test_descr = "SHA1 Digest Verify",
 435                 .test_data = &sha1_test_vector,
 436                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 437                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 438                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 439                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 440                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 441         },
 442         {
 443                 .test_descr = "HMAC-SHA1 Digest",
 444                 .test_data = &hmac_sha1_test_vector,
 445                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 446                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 447                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 448                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 449                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 450                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 451                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 452                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 453                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 454                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 455                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 456         },
 457         {
 458                 .test_descr = "HMAC-SHA1 Digest Scatter Gather",
 459                 .test_data = &hmac_sha1_test_vector,
 460                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 461                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_SG,
 462                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 463                             BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 464                             BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 465                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 466         },
 467         {
 468                 .test_descr = "HMAC-SHA1 Digest Verify",
 469                 .test_data = &hmac_sha1_test_vector,
 470                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 471                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 472                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 473                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 474                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 475                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 476                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 477                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 478                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 479                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 480                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 481         },
 482         {
 483                 .test_descr = "HMAC-SHA1 Digest Verify Scatter Gather",
 484                 .test_data = &hmac_sha1_test_vector,
 485                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 486                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_SG,
 487                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 488                             BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 489                             BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 490                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 491         },
 492         {
 493                 .test_descr = "SHA224 Digest",
 494                 .test_data = &sha224_test_vector,
 495                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 496                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 497                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 498                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 499                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 500         },
 501         {
 502                 .test_descr = "SHA224 Digest Verify",
 503                 .test_data = &sha224_test_vector,
 504                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 505                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 506                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 507                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 508                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 509         },
 510         {
 511                 .test_descr = "HMAC-SHA224 Digest",
 512                 .test_data = &hmac_sha224_test_vector,
 513                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 514                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 515                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 516                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 517                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 518                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 519                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 520                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 521                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 522                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 523         },
 524         {
 525                 .test_descr = "HMAC-SHA224 Digest Verify",
 526                 .test_data = &hmac_sha224_test_vector,
 527                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 528                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 529                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 530                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 531                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 532                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 533                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 534                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 535                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 536                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 537         },
 538         {
 539                 .test_descr = "SHA256 Digest",
 540                 .test_data = &sha256_test_vector,
 541                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 542                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 543                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 544                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 545                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 546         },
 547         {
 548                 .test_descr = "SHA256 Digest Verify",
 549                 .test_data = &sha256_test_vector,
 550                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 551                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 552                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 553                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 554                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 555         },
 556         {
 557                 .test_descr = "HMAC-SHA256 Digest",
 558                 .test_data = &hmac_sha256_test_vector,
 559                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 560                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 561                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 562                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 563                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 564                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 565                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 566                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 567                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 568                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 569                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 570         },
 571         {
 572                 .test_descr = "HMAC-SHA256 Digest Verify",
 573                 .test_data = &hmac_sha256_test_vector,
 574                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 575                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 576                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 577                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 578                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 579                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 580                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 581                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 582                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 583                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 584                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 585         },
 586         {
 587                 .test_descr = "SHA384 Digest",
 588                 .test_data = &sha384_test_vector,
 589                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 590                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 591                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 592                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 593                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 594         },
 595         {
 596                 .test_descr = "SHA384 Digest Verify",
 597                 .test_data = &sha384_test_vector,
 598                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 599                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 600                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 601                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 602                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 603         },
 604         {
 605                 .test_descr = "HMAC-SHA384 Digest",
 606                 .test_data = &hmac_sha384_test_vector,
 607                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 608                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 609                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 610                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 611                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 612                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 613                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 614                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 615                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 616                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 617                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 618         },
 619         {
 620                 .test_descr = "HMAC-SHA384 Digest Verify",
 621                 .test_data = &hmac_sha384_test_vector,
 622                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 623                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 624                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 625                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 626                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 627                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 628                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 629                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 630                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 631                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 632                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 633         },
 634         {
 635                 .test_descr = "SHA512 Digest",
 636                 .test_data = &sha512_test_vector,
 637                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 638                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 639                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 640                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 641                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 642         },
 643         {
 644                 .test_descr = "SHA512 Digest Verify",
 645                 .test_data = &sha512_test_vector,
 646                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 647                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 648                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 649                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 650                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 651         },
 652         {
 653                 .test_descr = "HMAC-SHA512 Digest",
 654                 .test_data = &hmac_sha512_test_vector,
 655                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 656                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 657                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 658                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 659                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 660                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 661                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 662                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 663                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 664                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 665                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 666         },
 667         {
 668                 .test_descr = "HMAC-SHA512 Digest Verify",
 669                 .test_data = &hmac_sha512_test_vector,
 670                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 671                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 672                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 673                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 674                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 675                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 676                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 677                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 678                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 679                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 680                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 681         },
 682         {
 683                 .test_descr = "CMAC Digest 12B",
 684                 .test_data = &cmac_test_vector_12,
 685                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 686                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
 687                         BLOCKCIPHER_TEST_TARGET_PMD_QAT
 688         },
 689         {
 690                 .test_descr = "CMAC Digest Verify 12B",
 691                 .test_data = &cmac_test_vector_12,
 692                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 693                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
 694                         BLOCKCIPHER_TEST_TARGET_PMD_QAT
 695         },
 696         {
 697                 .test_descr = "CMAC Digest 16B",
 698                 .test_data = &cmac_test_vector,
 699                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 700                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
 701                         BLOCKCIPHER_TEST_TARGET_PMD_QAT
 702         },
 703         {
 704                 .test_descr = "CMAC Digest Verify 16B",
 705                 .test_data = &cmac_test_vector,
 706                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 707                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
 708                         BLOCKCIPHER_TEST_TARGET_PMD_QAT
 709         }
 710 };
 711
 712 #endif /* TEST_CRYPTODEV_HASH_TEST_VECTORS_H_ */