ceph/src/spdk/dpdk/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 cmac_test_vector_12 = {
 362         .auth_algo = RTE_CRYPTO_AUTH_AES_CMAC,
 363         .ciphertext = {
 364                 .data = plaintext_hash,
 365                 .len = 512
 366         },
 367         .auth_key = {
 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                         0x4C, 0x77, 0x87, 0xA0, 0x78, 0x8E, 0xEA, 0x96,
 377                         0xC1, 0xEB, 0x1E, 0x4E, 0x95, 0x8F, 0xED, 0x27
 378                 },
 379                 .len = 12,
 380                 .truncated_len = 12
 381         }
 382 };
 383
 384 static const struct blockcipher_test_case hash_test_cases[] = {
 385         {
 386                 .test_descr = "MD5 Digest",
 387                 .test_data = &md5_test_vector,
 388                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 389                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 390                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 391                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 392         },
 393         {
 394                 .test_descr = "MD5 Digest Verify",
 395                 .test_data = &md5_test_vector,
 396                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 397                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 398                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 399                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 400         },
 401         {
 402                 .test_descr = "HMAC-MD5 Digest",
 403                 .test_data = &hmac_md5_test_vector,
 404                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 405                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 406                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 407                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 408                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 409                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 410                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 411                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 412                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 413                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 414         },
 415         {
 416                 .test_descr = "HMAC-MD5 Digest Verify",
 417                 .test_data = &hmac_md5_test_vector,
 418                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 419                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 420                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 421                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 422                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 423                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 424                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 425                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 426                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 427                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 428         },
 429         {
 430                 .test_descr = "SHA1 Digest",
 431                 .test_data = &sha1_test_vector,
 432                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 433                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 434                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 435                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 436 #if IMB_VERSION_NUM >= IMB_VERSION(0, 52, 0)
 437                             BLOCKCIPHER_TEST_TARGET_PMD_MB |
 438 #endif
 439                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 440         },
 441         {
 442                 .test_descr = "SHA1 Digest Verify",
 443                 .test_data = &sha1_test_vector,
 444                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 445                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 446                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 447                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 448 #if IMB_VERSION_NUM >= IMB_VERSION(0, 52, 0)
 449                             BLOCKCIPHER_TEST_TARGET_PMD_MB |
 450 #endif
 451                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 452         },
 453         {
 454                 .test_descr = "HMAC-SHA1 Digest",
 455                 .test_data = &hmac_sha1_test_vector,
 456                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 457                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 458                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 459                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 460                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 461                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 462                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 463                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 464                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 465                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 466                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 467         },
 468         {
 469                 .test_descr = "HMAC-SHA1 Digest Scatter Gather",
 470                 .test_data = &hmac_sha1_test_vector,
 471                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 472                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_SG,
 473                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 474                             BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 475                             BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 476                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 477         },
 478         {
 479                 .test_descr = "HMAC-SHA1 Digest Verify",
 480                 .test_data = &hmac_sha1_test_vector,
 481                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 482                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 483                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 484                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 485                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 486                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 487                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 488                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 489                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 490                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 491                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 492         },
 493         {
 494                 .test_descr = "HMAC-SHA1 Digest Verify Scatter Gather",
 495                 .test_data = &hmac_sha1_test_vector,
 496                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 497                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_SG,
 498                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 499                             BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 500                             BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 501                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 502         },
 503         {
 504                 .test_descr = "SHA224 Digest",
 505                 .test_data = &sha224_test_vector,
 506                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 507                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 508                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 509                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 510 #if IMB_VERSION_NUM >= IMB_VERSION(0, 52, 0)
 511                             BLOCKCIPHER_TEST_TARGET_PMD_MB |
 512 #endif
 513                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 514         },
 515         {
 516                 .test_descr = "SHA224 Digest Verify",
 517                 .test_data = &sha224_test_vector,
 518                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 519                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 520                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 521                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 522 #if IMB_VERSION_NUM >= IMB_VERSION(0, 52, 0)
 523                             BLOCKCIPHER_TEST_TARGET_PMD_MB |
 524 #endif
 525                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 526         },
 527         {
 528                 .test_descr = "HMAC-SHA224 Digest",
 529                 .test_data = &hmac_sha224_test_vector,
 530                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 531                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 532                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 533                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 534                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 535                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 536                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 537                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 538                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 539                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 540         },
 541         {
 542                 .test_descr = "HMAC-SHA224 Digest Verify",
 543                 .test_data = &hmac_sha224_test_vector,
 544                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 545                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 546                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 547                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 548                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 549                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 550                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 551                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 552                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 553                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 554         },
 555         {
 556                 .test_descr = "SHA256 Digest",
 557                 .test_data = &sha256_test_vector,
 558                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 559                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 560                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 561                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 562 #if IMB_VERSION_NUM >= IMB_VERSION(0, 52, 0)
 563                             BLOCKCIPHER_TEST_TARGET_PMD_MB |
 564 #endif
 565                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 566         },
 567         {
 568                 .test_descr = "SHA256 Digest Verify",
 569                 .test_data = &sha256_test_vector,
 570                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 571                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 572                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 573                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 574 #if IMB_VERSION_NUM >= IMB_VERSION(0, 52, 0)
 575                             BLOCKCIPHER_TEST_TARGET_PMD_MB |
 576 #endif
 577                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 578         },
 579         {
 580                 .test_descr = "HMAC-SHA256 Digest",
 581                 .test_data = &hmac_sha256_test_vector,
 582                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 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_QAT |
 590                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 591                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 592                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 593         },
 594         {
 595                 .test_descr = "HMAC-SHA256 Digest Verify",
 596                 .test_data = &hmac_sha256_test_vector,
 597                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 598                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 599                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 600                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 601                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 602                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 603                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 604                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 605                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 606                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 607                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 608         },
 609         {
 610                 .test_descr = "SHA384 Digest",
 611                 .test_data = &sha384_test_vector,
 612                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 613                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 614                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 615                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 616 #if IMB_VERSION_NUM >= IMB_VERSION(0, 52, 0)
 617                             BLOCKCIPHER_TEST_TARGET_PMD_MB |
 618 #endif
 619                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 620         },
 621         {
 622                 .test_descr = "SHA384 Digest Verify",
 623                 .test_data = &sha384_test_vector,
 624                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 625                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 626                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 627                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 628 #if IMB_VERSION_NUM >= IMB_VERSION(0, 52, 0)
 629                             BLOCKCIPHER_TEST_TARGET_PMD_MB |
 630 #endif
 631                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 632         },
 633         {
 634                 .test_descr = "HMAC-SHA384 Digest",
 635                 .test_data = &hmac_sha384_test_vector,
 636                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 637                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 638                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 639                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 640                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 641                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 642                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 643                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 644                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 645                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 646                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 647         },
 648         {
 649                 .test_descr = "HMAC-SHA384 Digest Verify",
 650                 .test_data = &hmac_sha384_test_vector,
 651                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 652                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 653                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 654                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 655                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 656                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 657                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 658                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 659                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 660                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 661                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 662         },
 663         {
 664                 .test_descr = "SHA512 Digest",
 665                 .test_data = &sha512_test_vector,
 666                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 667                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 668                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 669                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 670 #if IMB_VERSION_NUM >= IMB_VERSION(0, 52, 0)
 671                             BLOCKCIPHER_TEST_TARGET_PMD_MB |
 672 #endif
 673                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 674         },
 675         {
 676                 .test_descr = "SHA512 Digest Verify",
 677                 .test_data = &sha512_test_vector,
 678                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 679                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 680                             BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 681                             BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 682 #if IMB_VERSION_NUM >= IMB_VERSION(0, 52, 0)
 683                             BLOCKCIPHER_TEST_TARGET_PMD_MB |
 684 #endif
 685                             BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 686         },
 687         {
 688                 .test_descr = "HMAC-SHA512 Digest",
 689                 .test_data = &hmac_sha512_test_vector,
 690                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 691                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 692                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 693                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 694                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 695                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 696                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 697                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 698                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 699                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 700                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 701         },
 702         {
 703                 .test_descr = "HMAC-SHA512 Digest Verify",
 704                 .test_data = &hmac_sha512_test_vector,
 705                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 706                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
 707                         BLOCKCIPHER_TEST_TARGET_PMD_MB |
 708                         BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER |
 709                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC |
 710                         BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC |
 711                         BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR |
 712                         BLOCKCIPHER_TEST_TARGET_PMD_QAT |
 713                         BLOCKCIPHER_TEST_TARGET_PMD_CCP |
 714                         BLOCKCIPHER_TEST_TARGET_PMD_MVSAM |
 715                         BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX
 716         },
 717         {
 718                 .test_descr = "CMAC Digest 12B",
 719                 .test_data = &cmac_test_vector_12,
 720                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 721                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
 722                         BLOCKCIPHER_TEST_TARGET_PMD_QAT
 723         },
 724         {
 725                 .test_descr = "CMAC Digest Verify 12B",
 726                 .test_data = &cmac_test_vector_12,
 727                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 728                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
 729                         BLOCKCIPHER_TEST_TARGET_PMD_QAT
 730         },
 731         {
 732                 .test_descr = "CMAC Digest 16B",
 733                 .test_data = &cmac_test_vector,
 734                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
 735                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
 736                         BLOCKCIPHER_TEST_TARGET_PMD_QAT
 737         },
 738         {
 739                 .test_descr = "CMAC Digest Verify 16B",
 740                 .test_data = &cmac_test_vector,
 741                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
 742                 .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
 743                         BLOCKCIPHER_TEST_TARGET_PMD_QAT
 744         }
 745 };
 746
 747 #endif /* TEST_CRYPTODEV_HASH_TEST_VECTORS_H_ */