app/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                 .truncated_len = 20
 101         }
 102 };
 103
 104 static const struct blockcipher_test_data
 105 hmac_sha1_test_vector = {
 106         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
 107         .ciphertext = {
 108                 .data = plaintext_hash,
 109                 .len = 512
 110         },
 111         .auth_key = {
 112                 .data = {
 113                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 114                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 115                         0xDE, 0xF4, 0xDE, 0xAD
 116                 },
 117                 .len = 20
 118         },
 119         .digest = {
 120                 .data = {
 121                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
 122                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
 123                         0x3F, 0x91, 0x64, 0x59
 124                 },
 125                 .len = 20,
 126                 .truncated_len = 12
 127         }
 128 };
 129
 130 static const struct blockcipher_test_data
 131 sha224_test_vector = {
 132         .auth_algo = RTE_CRYPTO_AUTH_SHA224,
 133         .ciphertext = {
 134                 .data = plaintext_hash,
 135                 .len = 512
 136         },
 137         .digest = {
 138                 .data = {
 139                         0x91, 0xE7, 0xCD, 0x75, 0x14, 0x9C, 0xA9, 0xE9,
 140                         0x2E, 0x46, 0x12, 0x20, 0x22, 0xF9, 0x68, 0x28,
 141                         0x39, 0x26, 0xDF, 0xB5, 0x78, 0x62, 0xB2, 0x6E,
 142                         0x5E, 0x8F, 0x25, 0x84
 143                 },
 144                 .len = 28,
 145                 .truncated_len = 28
 146         }
 147 };
 148
 149 static const struct blockcipher_test_data
 150 hmac_sha224_test_vector = {
 151         .auth_algo = RTE_CRYPTO_AUTH_SHA224_HMAC,
 152         .ciphertext = {
 153                 .data = plaintext_hash,
 154                 .len = 512
 155         },
 156         .auth_key = {
 157                 .data = {
 158                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 159                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 160                         0xDE, 0xF4, 0xDE, 0xAD, 0x26, 0xEB, 0xAB, 0x92,
 161                         0xFB, 0xBF, 0xB0, 0x8C
 162                 },
 163                 .len = 28
 164         },
 165         .digest = {
 166                 .data = {
 167                         0x70, 0x0F, 0x04, 0x4D, 0x22, 0x02, 0x7D, 0x31,
 168                         0x36, 0xDA, 0x77, 0x19, 0xB9, 0x66, 0x37, 0x7B,
 169                         0xF1, 0x8A, 0x63, 0xBB, 0x5D, 0x1D, 0xE3, 0x9F,
 170                         0x92, 0xF6, 0xAA, 0x19
 171                 },
 172                 .len = 28,
 173                 .truncated_len = 14
 174         }
 175 };
 176
 177 static const struct blockcipher_test_data
 178 sha256_test_vector = {
 179         .auth_algo = RTE_CRYPTO_AUTH_SHA256,
 180         .ciphertext = {
 181                 .data = plaintext_hash,
 182                 .len = 512
 183         },
 184         .digest = {
 185                 .data = {
 186                         0x7F, 0xF1, 0x0C, 0xF5, 0x90, 0x97, 0x19, 0x0F,
 187                         0x00, 0xE4, 0x83, 0x01, 0xCA, 0x59, 0x00, 0x2E,
 188                         0x1F, 0xC7, 0x84, 0xEE, 0x76, 0xA6, 0x39, 0x15,
 189                         0x76, 0x2F, 0x87, 0xF9, 0x01, 0x06, 0xF3, 0xB7
 190                 },
 191                 .len = 32,
 192                 .truncated_len = 32
 193         }
 194 };
 195
 196 static const struct blockcipher_test_data
 197 hmac_sha256_test_vector = {
 198         .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC,
 199         .ciphertext = {
 200                 .data = plaintext_hash,
 201                 .len = 512
 202         },
 203         .auth_key = {
 204                 .data = {
 205                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 206                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 207                         0xDE, 0xF4, 0xDE, 0xAD, 0x26, 0xEB, 0xAB, 0x92,
 208                         0xFB, 0xBF, 0xB0, 0x8C, 0x29, 0x87, 0x90, 0xAC
 209                 },
 210                 .len = 32
 211         },
 212         .digest = {
 213                 .data = {
 214                         0xAF, 0x8F, 0x70, 0x1B, 0x4B, 0xAF, 0x34, 0xCB,
 215                         0x02, 0x24, 0x48, 0x45, 0x83, 0x52, 0x8F, 0x22,
 216                         0x06, 0x4D, 0x64, 0x09, 0x0A, 0xCC, 0x02, 0x77,
 217                         0x71, 0x83, 0x48, 0x71, 0x07, 0x02, 0x25, 0x17
 218                 },
 219                 .len = 32,
 220                 .truncated_len = 16
 221         }
 222 };
 223
 224 static const struct blockcipher_test_data
 225 sha384_test_vector = {
 226         .auth_algo = RTE_CRYPTO_AUTH_SHA384,
 227         .ciphertext = {
 228                 .data = plaintext_hash,
 229                 .len = 512
 230         },
 231         .digest = {
 232                 .data = {
 233                         0x1D, 0xE7, 0x3F, 0x55, 0x86, 0xFE, 0x48, 0x9F,
 234                         0xAC, 0xC6, 0x85, 0x32, 0xFA, 0x8E, 0xA6, 0x77,
 235                         0x25, 0x84, 0xA5, 0x98, 0x8D, 0x0B, 0x80, 0xF4,
 236                         0xEB, 0x2C, 0xFB, 0x6C, 0xEA, 0x7B, 0xFD, 0xD5,
 237                         0xAD, 0x41, 0xAB, 0x15, 0xB0, 0x03, 0x15, 0xEC,
 238                         0x9E, 0x3D, 0xED, 0xCB, 0x80, 0x7B, 0xF4, 0xB6
 239                 },
 240                 .len = 48,
 241                 .truncated_len = 48
 242         }
 243 };
 244
 245 static const struct blockcipher_test_data
 246 hmac_sha384_test_vector = {
 247         .auth_algo = RTE_CRYPTO_AUTH_SHA384_HMAC,
 248         .ciphertext = {
 249                 .data = plaintext_hash,
 250                 .len = 512
 251         },
 252         .auth_key = {
 253                 .data = {
 254                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 255                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 256                         0xDE, 0xF4, 0xDE, 0xAD, 0x26, 0xEB, 0xAB, 0x92,
 257                         0xFB, 0xBF, 0xB0, 0x8C, 0x29, 0x87, 0x90, 0xAC,
 258                         0x39, 0x8B, 0x5C, 0x49, 0x68, 0x1E, 0x3A, 0x05,
 259                         0xCC, 0x68, 0x5C, 0x76, 0xCB, 0x3C, 0x71, 0x89
 260                 },
 261                 .len = 48
 262         },
 263         .digest = {
 264                 .data = {
 265                         0xE2, 0x83, 0x18, 0x55, 0xB5, 0x8D, 0x94, 0x9B,
 266                         0x01, 0xB6, 0xE2, 0x57, 0x7A, 0x62, 0xF5, 0xF4,
 267                         0xAB, 0x39, 0xF3, 0x3C, 0x28, 0xA0, 0x0F, 0xCC,
 268                         0xEE, 0x1C, 0xF1, 0xF8, 0x69, 0xF1, 0x24, 0x3B,
 269                         0x10, 0x90, 0x0A, 0xE3, 0xF0, 0x59, 0xDD, 0xC0,
 270                         0x6F, 0xE6, 0x8C, 0x84, 0xD5, 0x03, 0xF8, 0x9E
 271                 },
 272                 .len = 48,
 273                 .truncated_len = 24
 274         }
 275 };
 276
 277 static const struct blockcipher_test_data
 278 sha512_test_vector = {
 279         .auth_algo = RTE_CRYPTO_AUTH_SHA512,
 280         .ciphertext = {
 281                 .data = plaintext_hash,
 282                 .len = 512
 283         },
 284         .digest = {
 285                 .data = {
 286                         0xB9, 0xBA, 0x28, 0x48, 0x3C, 0xC2, 0xD3, 0x65,
 287                         0x4A, 0xD6, 0x00, 0x1D, 0xCE, 0x61, 0x64, 0x54,
 288                         0x45, 0x8C, 0x64, 0x0E, 0xED, 0x0E, 0xD8, 0x1C,
 289                         0x72, 0xCE, 0xD2, 0x44, 0x91, 0xC8, 0xEB, 0xC7,
 290                         0x99, 0xC5, 0xCA, 0x89, 0x72, 0x64, 0x96, 0x41,
 291                         0xC8, 0xEA, 0xB2, 0x4E, 0xD1, 0x21, 0x13, 0x49,
 292                         0x64, 0x4E, 0x15, 0x68, 0x12, 0x67, 0x26, 0x0F,
 293                         0x2C, 0x3C, 0x83, 0x25, 0x27, 0x86, 0xF0, 0xDB
 294                 },
 295                 .len = 64,
 296                 .truncated_len = 64
 297         }
 298 };
 299
 300 static const struct blockcipher_test_data
 301 hmac_sha512_test_vector = {
 302         .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC,
 303         .ciphertext = {
 304                 .data = plaintext_hash,
 305                 .len = 512
 306         },
 307         .auth_key = {
 308                 .data = {
 309                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 310                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 311                         0xDE, 0xF4, 0xDE, 0xAD, 0x26, 0xEB, 0xAB, 0x92,
 312                         0xFB, 0xBF, 0xB0, 0x8C, 0x29, 0x87, 0x90, 0xAC,
 313                         0x39, 0x8B, 0x5C, 0x49, 0x68, 0x1E, 0x3A, 0x05,
 314                         0xCC, 0x68, 0x5C, 0x76, 0xCB, 0x3C, 0x71, 0x89,
 315                         0xDE, 0xAA, 0x36, 0x44, 0x98, 0x93, 0x97, 0x1E,
 316                         0x6D, 0x53, 0x83, 0x87, 0xB3, 0xB7, 0x56, 0x41
 317                 },
 318                 .len = 64
 319         },
 320         .digest = {
 321                 .data = {
 322                         0xB8, 0x0B, 0x35, 0x97, 0x3F, 0x24, 0x3F, 0x05,
 323                         0x2A, 0x7F, 0x2F, 0xD8, 0xD7, 0x56, 0x58, 0xAD,
 324                         0x6F, 0x8D, 0x1F, 0x4C, 0x30, 0xF9, 0xA8, 0x29,
 325                         0x7A, 0xE0, 0x8D, 0x88, 0xF5, 0x2E, 0x94, 0xF5,
 326                         0x06, 0xF7, 0x5D, 0x57, 0x32, 0xA8, 0x49, 0x29,
 327                         0xEA, 0x6B, 0x6D, 0x95, 0xBD, 0x76, 0xF5, 0x79,
 328                         0x97, 0x37, 0x0F, 0xBE, 0xC2, 0x45, 0xA0, 0x87,
 329                         0xAF, 0x24, 0x27, 0x0C, 0x78, 0xBA, 0xBE, 0x20
 330                 },
 331                 .len = 64,
 332                 .truncated_len = 32
 333         }
 334 };
 335
 336 static const struct blockcipher_test_data
 337 cmac_test_vector = {
 338         .auth_algo = RTE_CRYPTO_AUTH_AES_CMAC,
 339         .ciphertext = {
 340                 .data = plaintext_hash,
 341                 .len = 512
 342         },
 343         .auth_key = {
 344                 .data = {
 345                         0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
 346                         0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
 347                 },
 348                 .len = 16
 349         },
 350         .digest = {
 351                 .data = {
 352                         0x4C, 0x77, 0x87, 0xA0, 0x78, 0x8E, 0xEA, 0x96,
 353                         0xC1, 0xEB, 0x1E, 0x4E, 0x95, 0x8F, 0xED, 0x27
 354                 },
 355                 .len = 16,
 356                 .truncated_len = 16
 357         }
 358 };
 359
 360 static const struct blockcipher_test_data
 361 null_auth_test_vector = {
 362         .auth_algo = RTE_CRYPTO_AUTH_NULL,
 363         .ciphertext = {         /* arbitrary data - shouldn't be used */
 364                 .data = plaintext_hash,
 365                 .len = 512
 366         },
 367         .auth_key = {           /* arbitrary data - shouldn't be used */
 368                 .data = {
 369                         0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
 370                         0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
 371                 },
 372                 .len = 16
 373         },
 374         .digest = {
 375                 .data = {
 376                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 377                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 378                         0x00, 0x00, 0x00, 0x00
 379                 },
 380                 .len = 20,
 381                 .truncated_len = 12
 382         }
 383 };
 384
 385 static const struct blockcipher_test_data
 386 cmac_test_vector_12 = {
 387         .auth_algo = RTE_CRYPTO_AUTH_AES_CMAC,
 388         .ciphertext = {
 389                 .data = plaintext_hash,
 390                 .len = 512
 391         },
 392         .auth_key = {
 393                 .data = {
 394                         0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
 395                         0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
 396                 },
 397                 .len = 16
 398         },
 399         .digest = {
 400                 .data = {
 401                         0x4C, 0x77, 0x87, 0xA0, 0x78, 0x8E, 0xEA, 0x96,
 402                         0xC1, 0xEB, 0x1E, 0x4E, 0x95, 0x8F, 0xED, 0x27
 403                 },
 404                 .len = 12,
 405                 .truncated_len = 12
 406         }
 407 };
 408
 409 static const struct blockcipher_test_case hash_test_cases[] = {
 410         {
 411                 .test_descr = "MD5 Digest",
 412                 .test_data = &md5_test_vector,
 413                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 414                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 415                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 416                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 417                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 418         },
 419         {
 420                 .test_descr = "MD5 Digest Verify",
 421                 .test_data = &md5_test_vector,
 422                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 423                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 424                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 425                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 426                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 427         },
 428         {
 429                 .test_descr = "HMAC-MD5 Digest",
 430                 .test_data = &hmac_md5_test_vector,
 431                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 432                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 433                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 434                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 435                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 436                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 437                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 438                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 439                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 440                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 441                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 442         },
 443         {
 444                 .test_descr = "HMAC-MD5 Digest Verify",
 445                 .test_data = &hmac_md5_test_vector,
 446                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 447                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 448                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 449                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 450                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 451                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 452                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 453                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 454                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 455                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 456                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 457         },
 458         {
 459                 .test_descr = "SHA1 Digest",
 460                 .test_data = &sha1_test_vector,
 461                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 462                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 463                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 464                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 465 #if IMB_VERSION_NUM >= IMB_VERSION(0, 52, 0)
 466                             BLOCKCIPHER_TEST_TARGET_PMD_MB |
 467 #endif
 468                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 469                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 470         },
 471         {
 472                 .test_descr = "SHA1 Digest Verify",
 473                 .test_data = &sha1_test_vector,
 474                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 475                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 476                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 477                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 478 #if IMB_VERSION_NUM >= IMB_VERSION(0, 52, 0)
 479                             BLOCKCIPHER_TEST_TARGET_PMD_MB |
 480 #endif
 481                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 482                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 483         },
 484         {
 485                 .test_descr = "HMAC-SHA1 Digest",
 486                 .test_data = &hmac_sha1_test_vector,
 487                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 488                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 489                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 490                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 491                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 492                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 493                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 494                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 495                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 496                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 497                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 498                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 499         },
 500         {
 501                 .test_descr = "HMAC-SHA1 Digest Scatter Gather",
 502                 .test_data = &hmac_sha1_test_vector,
 503                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 504                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_SG,
 505                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 506                             BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 507                             BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 508                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 509                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 510         },
 511         {
 512                 .test_descr = "HMAC-SHA1 Digest Verify",
 513                 .test_data = &hmac_sha1_test_vector,
 514                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 515                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 516                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 517                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 518                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 519                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 520                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 521                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 522                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 523                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 524                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 525                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 526         },
 527         {
 528                 .test_descr = "HMAC-SHA1 Digest Verify Scatter Gather",
 529                 .test_data = &hmac_sha1_test_vector,
 530                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 531                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_SG,
 532                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 533                             BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 534                             BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 535                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 536                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 537         },
 538         {
 539                 .test_descr = "SHA224 Digest",
 540                 .test_data = &sha224_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 #if IMB_VERSION_NUM >= IMB_VERSION(0, 52, 0)
 546                             BLOCKCIPHER_TEST_TARGET_PMD_MB |
 547 #endif
 548                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 549                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 550         },
 551         {
 552                 .test_descr = "SHA224 Digest Verify",
 553                 .test_data = &sha224_test_vector,
 554                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 555                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 556                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 557                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 558 #if IMB_VERSION_NUM >= IMB_VERSION(0, 52, 0)
 559                             BLOCKCIPHER_TEST_TARGET_PMD_MB |
 560 #endif
 561                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 562                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 563         },
 564         {
 565                 .test_descr = "HMAC-SHA224 Digest",
 566                 .test_data = &hmac_sha224_test_vector,
 567                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 568                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 569                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 570                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 571                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 572                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 573                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 574                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 575                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 576                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 577                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 578         },
 579         {
 580                 .test_descr = "HMAC-SHA224 Digest Verify",
 581                 .test_data = &hmac_sha224_test_vector,
 582                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 583                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 584                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 585                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 586                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 587                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 588                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 589                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 590                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 591                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 592                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 593         },
 594         {
 595                 .test_descr = "SHA256 Digest",
 596                 .test_data = &sha256_test_vector,
 597                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 598                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 599                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 600                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 601 #if IMB_VERSION_NUM >= IMB_VERSION(0, 52, 0)
 602                             BLOCKCIPHER_TEST_TARGET_PMD_MB |
 603 #endif
 604                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 605                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 606         },
 607         {
 608                 .test_descr = "SHA256 Digest Verify",
 609                 .test_data = &sha256_test_vector,
 610                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 611                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 612                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 613                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 614 #if IMB_VERSION_NUM >= IMB_VERSION(0, 52, 0)
 615                             BLOCKCIPHER_TEST_TARGET_PMD_MB |
 616 #endif
 617                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 618                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 619         },
 620         {
 621                 .test_descr = "HMAC-SHA256 Digest",
 622                 .test_data = &hmac_sha256_test_vector,
 623                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 624                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 625                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 626                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 627                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 628                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 629                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 630                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 631                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 632                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 633                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 634                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 635         },
 636         {
 637                 .test_descr = "HMAC-SHA256 Digest Verify",
 638                 .test_data = &hmac_sha256_test_vector,
 639                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 640                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 641                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 642                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 643                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 644                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 645                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 646                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 647                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 648                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 649                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 650                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 651         },
 652         {
 653                 .test_descr = "SHA384 Digest",
 654                 .test_data = &sha384_test_vector,
 655                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 656                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 657                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 658                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 659 #if IMB_VERSION_NUM >= IMB_VERSION(0, 52, 0)
 660                             BLOCKCIPHER_TEST_TARGET_PMD_MB |
 661 #endif
 662                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 663                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 664         },
 665         {
 666                 .test_descr = "SHA384 Digest Verify",
 667                 .test_data = &sha384_test_vector,
 668                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 669                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 670                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 671                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 672 #if IMB_VERSION_NUM >= IMB_VERSION(0, 52, 0)
 673                             BLOCKCIPHER_TEST_TARGET_PMD_MB |
 674 #endif
 675                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 676                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 677         },
 678         {
 679                 .test_descr = "HMAC-SHA384 Digest",
 680                 .test_data = &hmac_sha384_test_vector,
 681                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 682                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 683                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 684                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 685                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 686                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 687                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 688                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 689                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 690                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 691                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 692                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 693         },
 694         {
 695                 .test_descr = "HMAC-SHA384 Digest Verify",
 696                 .test_data = &hmac_sha384_test_vector,
 697                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 698                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 699                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 700                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 701                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 702                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 703                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 704                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 705                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 706                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 707                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 708                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 709         },
 710         {
 711                 .test_descr = "SHA512 Digest",
 712                 .test_data = &sha512_test_vector,
 713                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 714                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 715                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 716                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 717 #if IMB_VERSION_NUM >= IMB_VERSION(0, 52, 0)
 718                             BLOCKCIPHER_TEST_TARGET_PMD_MB |
 719 #endif
 720                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 721         },
 722         {
 723                 .test_descr = "SHA512 Digest Verify",
 724                 .test_data = &sha512_test_vector,
 725                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 726                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 727                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 728                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 729 #if IMB_VERSION_NUM >= IMB_VERSION(0, 52, 0)
 730                             BLOCKCIPHER_TEST_TARGET_PMD_MB |
 731 #endif
 732                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 733                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 734         },
 735         {
 736                 .test_descr = "HMAC-SHA512 Digest",
 737                 .test_data = &hmac_sha512_test_vector,
 738                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 739                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 740                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 741                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 742                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 743                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 744                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 745                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 746                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 747                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 748                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 749                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 750         },
 751         {
 752                 .test_descr = "HMAC-SHA512 Digest Verify",
 753                 .test_data = &hmac_sha512_test_vector,
 754                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 755                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 756                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 757                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 758                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 759                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 760                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 761                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 762                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 763                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 764                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX |
 765                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX2
 766         },
 767         {
 768                 .test_descr = "CMAC Digest 12B",
 769                 .test_data = &cmac_test_vector_12,
 770                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 771                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
 772                         BLOCKCIPHER_TEST_TARGET_PMD_QAT
 773         },
 774         {
 775                 .test_descr = "CMAC Digest Verify 12B",
 776                 .test_data = &cmac_test_vector_12,
 777                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 778                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
 779                         BLOCKCIPHER_TEST_TARGET_PMD_QAT
 780         },
 781         {
 782                 .test_descr = "CMAC Digest 16B",
 783                 .test_data = &cmac_test_vector,
 784                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 785                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
 786                         BLOCKCIPHER_TEST_TARGET_PMD_QAT
 787         },
 788         {
 789                 .test_descr = "CMAC Digest Verify 16B",
 790                 .test_data = &cmac_test_vector,
 791                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 792                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
 793                         BLOCKCIPHER_TEST_TARGET_PMD_QAT
 794         },
 795         {
 796                 .test_descr = "NULL algo - auth generate",
 797                 .test_data = &null_auth_test_vector,
 798                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 799                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_NULL |
 800                         BLOCKCIPHER_TEST_TARGET_PMD_QAT
 801         },
 802         {
 803                 .test_descr = "NULL algo - auth verify",
 804                 .test_data = &null_auth_test_vector,
 805                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 806                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_NULL |
 807                         BLOCKCIPHER_TEST_TARGET_PMD_QAT
 808         },
 809         {
 810                 .test_descr = "NULL algo - auth generate - OOP",
 811                 .test_data = &null_auth_test_vector,
 812                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 813                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
 814                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_QAT
 815         },
 816         {
 817                 .test_descr = "NULL algo - auth verify - OOP",
 818                 .test_data = &null_auth_test_vector,
 819                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 820                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
 821                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_QAT
 822         },
 823
 824 };
 825
 826 #endif /* TEST_CRYPTODEV_HASH_TEST_VECTORS_H_ */