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