app/test/test_cryptodev_aes_test_vectors.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2016-2019 Intel Corporation
   3  */
   4
   5 #ifndef TEST_CRYPTODEV_AES_TEST_VECTORS_H_
   6 #define TEST_CRYPTODEV_AES_TEST_VECTORS_H_
   7
   8 /* test vectors */
   9 static const uint8_t plaintext_aes128ctr[] = {
  10         0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,
  11         0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A,
  12         0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C,
  13         0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51,
  14         0x30, 0xC8, 0x1C, 0x46, 0xA3, 0x5C, 0xE4, 0x11,
  15         0xE5, 0xFB, 0xC1, 0x19, 0x1A, 0x0A, 0x52, 0xEF,
  16         0xF6, 0x9F, 0x24, 0x45, 0xDF, 0x4F, 0x9B, 0x17,
  17         0xAD, 0x2B, 0x41, 0x7B, 0xE6, 0x6C, 0x37, 0x10
  18 };
  19
  20 static const uint8_t ciphertext64_aes128ctr[] = {
  21         0x87, 0x4D, 0x61, 0x91, 0xB6, 0x20, 0xE3, 0x26,
  22         0x1B, 0xEF, 0x68, 0x64, 0x99, 0x0D, 0xB6, 0xCE,
  23         0x98, 0x06, 0xF6, 0x6B, 0x79, 0x70, 0xFD, 0xFF,
  24         0x86, 0x17, 0x18, 0x7B, 0xB9, 0xFF, 0xFD, 0xFF,
  25         0x5A, 0xE4, 0xDF, 0x3E, 0xDB, 0xD5, 0xD3, 0x5E,
  26         0x5B, 0x4F, 0x09, 0x02, 0x0D, 0xB0, 0x3E, 0xAB,
  27         0x1E, 0x03, 0x1D, 0xDA, 0x2F, 0xBE, 0x03, 0xD1,
  28         0x79, 0x21, 0x70, 0xA0, 0xF3, 0x00, 0x9C, 0xEE
  29 };
  30
  31 static const uint8_t ciphertext64_aes128ctr_IV_12bytes[] = {
  32         0x28, 0x80, 0x28, 0xC7, 0x15, 0x99, 0xC5, 0xA8,
  33         0xDD, 0x53, 0xC2, 0x67, 0x1B, 0x86, 0xB8, 0x13,
  34         0xAB, 0x25, 0x39, 0x7A, 0xD2, 0x1F, 0x8B, 0x4B,
  35         0x94, 0x89, 0x2B, 0x65, 0xCF, 0x89, 0x1E, 0xDD,
  36         0xD4, 0x7C, 0xFD, 0x8D, 0x0E, 0xCD, 0x23, 0xA4,
  37         0xEB, 0x8C, 0x05, 0x58, 0x45, 0x4A, 0x63, 0x44,
  38         0x11, 0x42, 0x07, 0x17, 0xB4, 0xD2, 0xCC, 0x75,
  39         0xB7, 0x23, 0x99, 0xA9, 0xC5, 0x89, 0x7F, 0x66
  40 };
  41
  42 static const uint8_t plaintext_aes_docsis_bpi_cfb[] = {
  43         0x00, 0x01, 0x02, 0x88, 0xEE, 0x59, 0x7E
  44 };
  45
  46 static const uint8_t ciphertext_aes_docsis_bpi_cfb[] = {
  47         0xFC, 0x68, 0xA3, 0x55, 0x60, 0x37, 0xDC
  48 };
  49
  50 static const uint8_t ciphertext_aes256_docsis_bpi_cfb[] = {
  51         0xE3, 0x75, 0xF2, 0x30, 0x1F, 0x75, 0x9A
  52 };
  53
  54 static const uint8_t plaintext_aes_docsis_bpi_cbc_cfb[] = {
  55         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  56         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x91,
  57         0xD2, 0xD1, 0x9F
  58 };
  59
  60 static const uint8_t ciphertext_aes_docsis_bpi_cbc_cfb[] = {
  61         0x9D, 0xD1, 0x67, 0x4B, 0xBA, 0x61, 0x10, 0x1B,
  62         0x56, 0x75, 0x64, 0x74, 0x36, 0x4F, 0x10, 0x1D,
  63         0x44, 0xD4, 0x73
  64 };
  65
  66 static const uint8_t ciphertext_aes256_docsis_bpi_cbc_cfb[] = {
  67         0xD1, 0x28, 0x73, 0x1F, 0xB5, 0x28, 0xB5, 0x18,
  68         0xAB, 0x51, 0xAB, 0xC8, 0x98, 0x3D, 0xD1, 0xEE,
  69         0xE4, 0x43, 0x59
  70 };
  71
  72 static const uint8_t plaintext_aes192ctr[] = {
  73         0x01, 0x0F, 0x10, 0x1F, 0x20, 0x1C, 0x0E, 0xB8,
  74         0xFB, 0x5C, 0xCD, 0xCC, 0x1F, 0xF9, 0xAF, 0x0B,
  75         0x95, 0x03, 0x74, 0x99, 0x49, 0xE7, 0x62, 0x55,
  76         0xDA, 0xEA, 0x13, 0x20, 0x1D, 0xC6, 0xCC, 0xCC,
  77         0xD1, 0x70, 0x75, 0x47, 0x02, 0x2F, 0xFB, 0x86,
  78         0xBB, 0x6B, 0x23, 0xD2, 0xC9, 0x74, 0xD7, 0x7B,
  79         0x08, 0x03, 0x3B, 0x79, 0x39, 0xBB, 0x91, 0x29,
  80         0xDA, 0x14, 0x39, 0x8D, 0xFF, 0x81, 0x50, 0x96,
  81 };
  82
  83 static const uint8_t ciphertext64_aes192ctr[] = {
  84         0x4A, 0x6C, 0xC8, 0xCC, 0x96, 0x2A, 0x13, 0x84,
  85         0x1C, 0x36, 0x88, 0xE9, 0xE5, 0x94, 0x70, 0xB2,
  86         0x14, 0x5B, 0x13, 0x80, 0xEA, 0xD8, 0x8D, 0x37,
  87         0xFD, 0x70, 0xA8, 0x83, 0xE8, 0x2B, 0x88, 0x1E,
  88         0xBA, 0x94, 0x3F, 0xF6, 0xB3, 0x1F, 0xDE, 0x34,
  89         0xF3, 0x5B, 0x80, 0xE9, 0xAB, 0xF5, 0x1C, 0x29,
  90         0xB6, 0xD9, 0x76, 0x2B, 0x06, 0xC6, 0x74, 0xF1,
  91         0x59, 0x5E, 0x9E, 0xA5, 0x7B, 0x2D, 0xD7, 0xF0
  92 };
  93
  94 static const uint8_t ciphertext64_aes192ctr_IV_12bytes[] = {
  95         0x67, 0x65, 0xa9, 0xee, 0xfd, 0x31, 0x62, 0xfc,
  96         0xad, 0xfd, 0xc7, 0x25, 0xb7, 0x25, 0x16, 0xbe,
  97         0x25, 0xce, 0xc0, 0x1d, 0xda, 0xa9, 0xd3, 0xda,
  98         0x1b, 0x7d, 0x68, 0x6a, 0x6f, 0x06, 0xea, 0x47,
  99         0xa0, 0xe0, 0x15, 0xf4, 0xbd, 0x1b, 0x70, 0x34,
 100         0xd4, 0x6d, 0x1c, 0x84, 0x17, 0x91, 0x46, 0x0c,
 101         0xe8, 0xbc, 0x7a, 0xfb, 0x9f, 0x2a, 0x8f, 0xb4,
 102         0xd4, 0xf3, 0x6e, 0x5b, 0x75, 0xa0, 0xce, 0x32
 103 };
 104
 105 static const uint8_t plaintext_aes256ctr[] = {
 106         0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,
 107         0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A,
 108         0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C,
 109         0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51,
 110         0x30, 0xC8, 0x1C, 0x46, 0xA3, 0x5C, 0xE4, 0x11,
 111         0xE5, 0xFB, 0xC1, 0x19, 0x1A, 0x0A, 0x52, 0xEF,
 112         0xF6, 0x9F, 0x24, 0x45, 0xDF, 0x4F, 0x9B, 0x17,
 113         0xAD, 0x2B, 0x41, 0x7B, 0xE6, 0x6C, 0x37, 0x10
 114 };
 115
 116 static const uint8_t ciphertext64_aes256ctr[] = {
 117         0x60, 0x1E, 0xC3, 0x13, 0x77, 0x57, 0x89, 0xA5,
 118         0xB7, 0xA7, 0xF5, 0x04, 0xBB, 0xF3, 0xD2, 0x28,
 119         0xF4, 0x43, 0xE3, 0xCA, 0x4D, 0x62, 0xB5, 0x9A,
 120         0xCA, 0x84, 0xE9, 0x90, 0xCA, 0xCA, 0xF5, 0xC5,
 121         0x2B, 0x09, 0x30, 0xDA, 0xA2, 0x3D, 0xE9, 0x4C,
 122         0xE8, 0x70, 0x17, 0xBA, 0x2D, 0x84, 0x98, 0x8D,
 123         0xDF, 0xC9, 0xC5, 0x8D, 0xB6, 0x7A, 0xAD, 0xA6,
 124         0x13, 0xC2, 0xDD, 0x08, 0x45, 0x79, 0x41, 0xA6
 125 };
 126
 127 static const uint8_t ciphertext64_aes256ctr_IV_12bytes[] = {
 128         0x7B, 0x7A, 0x7D, 0x83, 0x85, 0xF8, 0x81, 0xF3,
 129         0x32, 0x33, 0xD9, 0xFB, 0x04, 0x73, 0xD4, 0x2F,
 130         0x70, 0xDE, 0x90, 0x3E, 0xD0, 0xA9, 0x93, 0x8A,
 131         0x91, 0xF3, 0xB5, 0x29, 0x4D, 0x2A, 0x74, 0xD0,
 132         0xDC, 0x4E, 0x5C, 0x9B, 0x97, 0x24, 0xD8, 0x02,
 133         0xFE, 0xAB, 0x38, 0xE8, 0x73, 0x51, 0x29, 0x7E,
 134         0xF1, 0xF9, 0x40, 0x78, 0xB1, 0x04, 0x7A, 0x78,
 135         0x61, 0x07, 0x47, 0xE6, 0x8C, 0x0F, 0xA8, 0x76
 136 };
 137
 138 static const uint8_t plaintext_aes_common[] = {
 139         "What a lousy earth! He wondered how many people "
 140         "were destitute that same night even in his own "
 141         "prosperous country, how many homes were "
 142         "shanties, how many husbands were drunk and "
 143         "wives socked, and how many children were "
 144         "bullied, abused, or abandoned. How many "
 145         "families hungered for food they could not "
 146         "afford to buy? How many hearts were broken? How "
 147         "many suicides would take place that same night, "
 148         "how many people would go insane? How many "
 149         "cockroaches and landlords would triumph? How "
 150         "many winners were losers, successes failures, "
 151         "and rich men poor men? How many wise guys were "
 152         "stupid? How many happy endings were unhappy "
 153         "endings? How many honest men were liars, brave "
 154         "men cowards, loyal men traitors, how many "
 155         "sainted men were corrupt, how many people in "
 156         "positions of trust had sold their souls to "
 157         "bodyguards, how many had never had souls? How "
 158         "many straight-and-narrow paths were crooked "
 159         "paths? How many best families were worst "
 160         "families and how many good people were bad "
 161         "people? When you added them all up and then "
 162         "subtracted, you might be left with only the "
 163         "children, and perhaps with Albert Einstein and "
 164         "an old violinist or sculptor somewhere."
 165 };
 166
 167 static const uint8_t ciphertext512_aes128cbc[] = {
 168         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
 169         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
 170         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
 171         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
 172         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
 173         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
 174         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
 175         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
 176         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
 177         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
 178         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
 179         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
 180         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
 181         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
 182         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
 183         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
 184         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
 185         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
 186         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
 187         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
 188         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
 189         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
 190         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
 191         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
 192         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
 193         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
 194         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
 195         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
 196         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
 197         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
 198         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
 199         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
 200         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
 201         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
 202         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
 203         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
 204         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
 205         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
 206         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
 207         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
 208         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
 209         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
 210         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
 211         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
 212         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
 213         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
 214         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
 215         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
 216         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
 217         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
 218         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
 219         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
 220         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
 221         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
 222         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
 223         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
 224         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
 225         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
 226         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
 227         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
 228         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
 229         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
 230         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
 231         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
 232 };
 233
 234 /* NULL cipher NULL auth 8-byte multiple test vector */
 235 static const struct blockcipher_test_data null_test_data_chain_x8_multiple = {
 236         .crypto_algo = RTE_CRYPTO_CIPHER_NULL,
 237         .cipher_key = { /* arbitrary data - shouldn't be used */
 238                 .data = {
 239                         0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
 240                         0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
 241                 },
 242                 .len = 16
 243         },
 244         .iv = {                 /* arbitrary data - shouldn't be used */
 245                 .data = {
 246                         0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
 247                         0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
 248                 },
 249                 .len = 16
 250         },
 251         .plaintext = {
 252                 .data = plaintext_aes_common,
 253                 .len = 512
 254         },
 255         .ciphertext = {
 256                 .data = plaintext_aes_common,
 257                 .len = 512
 258         },
 259         .auth_algo = RTE_CRYPTO_AUTH_NULL,
 260         .auth_key = {           /* arbitrary data - shouldn't be used */
 261                 .data = {
 262                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 263                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 264                         0xDE, 0xF4, 0xDE, 0xAD
 265                 },
 266                 .len = 20
 267         },
 268         .digest = {
 269                 .data = {
 270                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 271                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 272                         0x00, 0x00, 0x00, 0x00
 273                 },
 274                 .len = 20,
 275                 .truncated_len = 12
 276         }
 277 };
 278
 279 /* NULL cipher NULL auth 4-byte multiple test vector */
 280 static const struct blockcipher_test_data null_test_data_chain_x4_multiple = {
 281         .crypto_algo = RTE_CRYPTO_CIPHER_NULL,
 282         .cipher_key = { /* arbitrary data - shouldn't be used */
 283                 .data = {
 284                         0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
 285                         0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
 286                 },
 287                 .len = 16
 288         },
 289         .iv = {                 /* arbitrary data - shouldn't be used */
 290                 .data = {
 291                         0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
 292                         0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
 293                 },
 294                 .len = 16
 295         },
 296         .plaintext = {
 297                 .data = plaintext_aes128ctr,
 298                 .len = 20
 299         },
 300         .ciphertext = {
 301                 .data = plaintext_aes128ctr,
 302                 .len = 20
 303         },
 304         .auth_algo = RTE_CRYPTO_AUTH_NULL,
 305         .auth_key = {           /* arbitrary data - shouldn't be used */
 306                 .data = {
 307                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 308                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 309                         0xDE, 0xF4, 0xDE, 0xAD
 310                 },
 311                 .len = 20
 312         },
 313         .digest = {
 314                 .data = {
 315                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 316                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 317                         0x00, 0x00, 0x00, 0x00
 318                 },
 319                 .len = 20,
 320                 .truncated_len = 12
 321         }
 322 };
 323
 324 /* NULL cipher NULL auth 1-byte multiple test vector */
 325 static const struct blockcipher_test_data null_test_data_chain_x1_multiple = {
 326         .crypto_algo = RTE_CRYPTO_CIPHER_NULL,
 327         .cipher_key = { /* arbitrary data - shouldn't be used */
 328                 .data = {
 329                         0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
 330                         0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
 331                 },
 332                 .len = 16
 333         },
 334         .iv = {                 /* arbitrary data - shouldn't be used */
 335                 .data = {
 336                         0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
 337                         0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
 338                 },
 339                 .len = 16
 340         },
 341         .plaintext = {
 342                 .data = plaintext_aes128ctr,
 343                 .len = 21
 344         },
 345         .ciphertext = {
 346                 .data = plaintext_aes128ctr,
 347                 .len = 21
 348         },
 349         .auth_algo = RTE_CRYPTO_AUTH_NULL,
 350         .auth_key = {           /* arbitrary data - shouldn't be used */
 351                 .data = {
 352                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 353                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 354                         0xDE, 0xF4, 0xDE, 0xAD
 355                 },
 356                 .len = 20
 357         },
 358         .digest = {
 359                 .data = {
 360                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 361                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 362                         0x00, 0x00, 0x00, 0x00
 363                 },
 364                 .len = 20,
 365                 .truncated_len = 12
 366         }
 367 };
 368
 369 static const uint8_t ciphertext512_aes128cbc_aad[] = {
 370         0x57, 0x68, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6C,
 371         0x6F, 0x75, 0x73, 0x79, 0x6D, 0x70, 0xB4, 0xAD,
 372         0x09, 0x7C, 0xD7, 0x52, 0xD6, 0xF2, 0xBF, 0xD1,
 373         0x9D, 0x79, 0xC6, 0xB6, 0x8F, 0x94, 0xEB, 0xD8,
 374         0xBA, 0x5E, 0x01, 0x49, 0x7D, 0xB3, 0xC5, 0xFE,
 375         0x18, 0xF4, 0xE3, 0x60, 0x8C, 0x84, 0x68, 0x13,
 376         0x33, 0x06, 0x85, 0x60, 0xD3, 0xE7, 0x8A, 0xB5,
 377         0x23, 0xA2, 0xDE, 0x52, 0x5C, 0xB6, 0x26, 0x37,
 378         0xBB, 0x23, 0x8A, 0x38, 0x07, 0x85, 0xB6, 0x2E,
 379         0xC3, 0x69, 0x57, 0x79, 0x6B, 0xE4, 0xD7, 0x86,
 380         0x23, 0x72, 0x4C, 0x65, 0x49, 0x08, 0x1E, 0xF3,
 381         0xCC, 0x71, 0x4C, 0x45, 0x97, 0x03, 0xBC, 0xA0,
 382         0x9D, 0xF0, 0x4F, 0x5D, 0xEC, 0x40, 0x6C, 0xC6,
 383         0x52, 0xC0, 0x9D, 0x1C, 0xDC, 0x8B, 0xC2, 0xFA,
 384         0x35, 0xA7, 0x3A, 0x00, 0x04, 0x1C, 0xA6, 0x91,
 385         0x5D, 0xEB, 0x07, 0xA1, 0xB9, 0x3E, 0xD1, 0xB6,
 386         0xCA, 0x96, 0xEC, 0x71, 0xF7, 0x7D, 0xB6, 0x09,
 387         0x3D, 0x19, 0x6E, 0x75, 0x03, 0xC3, 0x1A, 0x4E,
 388         0x5B, 0x4D, 0xEA, 0xD9, 0x92, 0x96, 0x01, 0xFB,
 389         0xA3, 0xC2, 0x6D, 0xC4, 0x17, 0x6B, 0xB4, 0x3B,
 390         0x1E, 0x87, 0x54, 0x26, 0x95, 0x63, 0x07, 0x73,
 391         0xB6, 0xBA, 0x52, 0xD7, 0xA7, 0xD0, 0x9C, 0x75,
 392         0x8A, 0xCF, 0xC4, 0x3C, 0x4A, 0x55, 0x0E, 0x53,
 393         0xEC, 0xE0, 0x31, 0x51, 0xB7, 0xB7, 0xD2, 0xB4,
 394         0xF3, 0x2B, 0x70, 0x6D, 0x15, 0x9E, 0x57, 0x30,
 395         0x72, 0xE5, 0xA4, 0x71, 0x5F, 0xA4, 0xE8, 0x7C,
 396         0x46, 0x58, 0x36, 0x71, 0x91, 0x55, 0xAA, 0x99,
 397         0x3B, 0x3F, 0xF6, 0xA2, 0x9D, 0x27, 0xBF, 0xC2,
 398         0x62, 0x2C, 0x85, 0xB7, 0x51, 0xDD, 0xFD, 0x7B,
 399         0x8B, 0xB5, 0xDD, 0x2A, 0x73, 0xF8, 0x93, 0x9A,
 400         0x3F, 0xAD, 0x1D, 0xF0, 0x46, 0xD1, 0x76, 0x83,
 401         0x71, 0x4E, 0xD3, 0x0D, 0x64, 0x8C, 0xC3, 0xE6,
 402         0x03, 0xED, 0xE8, 0x53, 0x23, 0x1A, 0xC7, 0x86,
 403         0xEB, 0x87, 0xD6, 0x78, 0xF9, 0xFB, 0x9C, 0x1D,
 404         0xE7, 0x4E, 0xC0, 0x70, 0x27, 0x7A, 0x43, 0xE2,
 405         0x5D, 0xA4, 0x10, 0x40, 0xBE, 0x61, 0x0D, 0x2B,
 406         0x25, 0x08, 0x75, 0x91, 0xB5, 0x5A, 0x26, 0xC8,
 407         0x32, 0xA7, 0xC6, 0x88, 0xBF, 0x75, 0x94, 0xCC,
 408         0x58, 0xA4, 0xFE, 0x2F, 0xF7, 0x5C, 0xD2, 0x36,
 409         0x66, 0x55, 0xF0, 0xEA, 0xF5, 0x64, 0x43, 0xE7,
 410         0x6D, 0xE0, 0xED, 0xA1, 0x10, 0x0A, 0x84, 0x07,
 411         0x11, 0x88, 0xFA, 0xA1, 0xD3, 0xA0, 0x00, 0x5D,
 412         0xEB, 0xB5, 0x62, 0x01, 0x72, 0xC1, 0x9B, 0x39,
 413         0x0B, 0xD3, 0xAF, 0x04, 0x19, 0x42, 0xEC, 0xFF,
 414         0x4B, 0xB3, 0x5E, 0x87, 0x27, 0xE4, 0x26, 0x57,
 415         0x76, 0xCD, 0x36, 0x31, 0x5B, 0x94, 0x74, 0xFF,
 416         0x33, 0x91, 0xAA, 0xD1, 0x45, 0x34, 0xC2, 0x11,
 417         0xF0, 0x35, 0x44, 0xC9, 0xD5, 0xA2, 0x5A, 0xC2,
 418         0xE9, 0x9E, 0xCA, 0xE2, 0x6F, 0xD2, 0x40, 0xB4,
 419         0x93, 0x42, 0x78, 0x20, 0x92, 0x88, 0xC7, 0x16,
 420         0xCF, 0x15, 0x54, 0x7B, 0xE1, 0x46, 0x38, 0x69,
 421         0xB8, 0xE4, 0xF1, 0x81, 0xF0, 0x08, 0x6F, 0x92,
 422         0x6D, 0x1A, 0xD9, 0x93, 0xFA, 0xD7, 0x35, 0xFE,
 423         0x7F, 0x59, 0x43, 0x1D, 0x3A, 0x3B, 0xFC, 0xD0,
 424         0x14, 0x95, 0x1E, 0xB2, 0x04, 0x08, 0x4F, 0xC6,
 425         0xEA, 0xE8, 0x22, 0xF3, 0xD7, 0x66, 0x93, 0xAA,
 426         0xFD, 0xA0, 0xFE, 0x03, 0x96, 0x54, 0x78, 0x35,
 427         0x18, 0xED, 0xB7, 0x2F, 0x40, 0xE3, 0x8E, 0x22,
 428         0xC6, 0xDA, 0xB0, 0x8E, 0xA0, 0xA1, 0x62, 0x03,
 429         0x63, 0x34, 0x11, 0xF5, 0x9E, 0xAA, 0x6B, 0xC4,
 430         0x14, 0x75, 0x4C, 0xF4, 0xD8, 0xD9, 0xF1, 0x76,
 431         0xE3, 0xD3, 0x55, 0xCE, 0x22, 0x7D, 0x4A, 0xB7,
 432         0xBB, 0x7F, 0x4F, 0x09, 0x88, 0x70, 0x6E, 0x09,
 433         0x84, 0x6B, 0x24, 0x19, 0x2C, 0x20, 0x73, 0x75
 434 };
 435
 436 /* AES128-CTR-SHA1 test vector */
 437 static const struct blockcipher_test_data aes_test_data_1 = {
 438         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CTR,
 439         .cipher_key = {
 440                 .data = {
 441                         0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
 442                         0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
 443                 },
 444                 .len = 16
 445         },
 446         .iv = {
 447                 .data = {
 448                         0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
 449                         0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
 450                 },
 451                 .len = 16
 452         },
 453         .plaintext = {
 454                 .data = plaintext_aes128ctr,
 455                 .len = 64
 456         },
 457         .ciphertext = {
 458                 .data = ciphertext64_aes128ctr,
 459                 .len = 64
 460         },
 461         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
 462         .auth_key = {
 463                 .data = {
 464                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 465                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 466                         0xDE, 0xF4, 0xDE, 0xAD
 467                 },
 468                 .len = 20
 469         },
 470         .digest = {
 471                 .data = {
 472                         0x9B, 0x6F, 0x0C, 0x43, 0xF5, 0xC1, 0x3E, 0xB0,
 473                         0xB1, 0x70, 0xB8, 0x2B, 0x33, 0x09, 0xD2, 0xB2,
 474                         0x56, 0x20, 0xFB, 0xFE
 475                 },
 476                 .len = 20,
 477                 .truncated_len = 12
 478         }
 479 };
 480
 481 /** AES-192-CTR XCBC test vector */
 482 static const struct blockcipher_test_data aes_test_data_2 = {
 483         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CTR,
 484         .cipher_key = {
 485                 .data = {
 486                         0xCB, 0xC5, 0xED, 0x5B, 0xE7, 0x7C, 0xBD, 0x8C,
 487                         0x50, 0xD9, 0x30, 0xF2, 0xB5, 0x6A, 0x0E, 0x5F,
 488                         0xAA, 0xAE, 0xAD, 0xA2, 0x1F, 0x49, 0x52, 0xD4
 489                 },
 490                 .len = 24
 491         },
 492         .iv = {
 493                 .data = {
 494                         0x3F, 0x69, 0xA8, 0xCD, 0xE8, 0xF0, 0xEF, 0x40,
 495                         0xB8, 0x7A, 0x4B, 0xED, 0x2B, 0xAF, 0xBF, 0x57
 496                 },
 497                 .len = 16
 498         },
 499         .plaintext = {
 500                 .data = plaintext_aes192ctr,
 501                 .len = 64
 502         },
 503         .ciphertext = {
 504                 .data = ciphertext64_aes192ctr,
 505                 .len = 64
 506         },
 507         .auth_algo = RTE_CRYPTO_AUTH_AES_XCBC_MAC,
 508         .auth_key = {
 509                 .data = {
 510                         0x87, 0x61, 0x54, 0x53, 0xC4, 0x6D, 0xDD, 0x51,
 511                         0xE1, 0x9F, 0x86, 0x64, 0x39, 0x0A, 0xE6, 0x59
 512                 },
 513                 .len = 16
 514         },
 515         .digest = {
 516                 .data = {
 517                         0xCA, 0x33, 0xB3, 0x3B, 0x16, 0x94, 0xAA, 0x55,
 518                         0x36, 0x6B, 0x45, 0x46
 519                 },
 520                 .len = 12,
 521                 .truncated_len = 12
 522         }
 523 };
 524
 525 /** AES-256-CTR SHA1 test vector */
 526 static const struct blockcipher_test_data aes_test_data_3 = {
 527         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CTR,
 528         .cipher_key = {
 529                 .data = {
 530                         0x60, 0x3D, 0xEB, 0x10, 0x15, 0xCA, 0x71, 0xBE,
 531                         0x2B, 0x73, 0xAE, 0xF0, 0x85, 0x7D, 0x77, 0x81,
 532                         0x1F, 0x35, 0x2C, 0x07, 0x3B, 0x61, 0x08, 0xD7,
 533                         0x2D, 0x98, 0x10, 0xA3, 0x09, 0x14, 0xDF, 0xF4
 534                 },
 535                 .len = 32
 536         },
 537         .iv = {
 538                 .data = {
 539                         0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
 540                         0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
 541                 },
 542                 .len = 16
 543         },
 544         .plaintext = {
 545                 .data = plaintext_aes256ctr,
 546                 .len = 64
 547         },
 548         .ciphertext = {
 549                 .data = ciphertext64_aes256ctr,
 550                 .len = 64
 551         },
 552         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
 553         .auth_key = {
 554                 .data = {
 555                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 556                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 557                         0xDE, 0xF4, 0xDE, 0xAD
 558                 },
 559                 .len = 20
 560         },
 561         .digest = {
 562                 .data = {
 563                         0x3B, 0x1A, 0x9D, 0x82, 0x35, 0xD5, 0xDD, 0x64,
 564                         0xCC, 0x1B, 0xA9, 0xC0, 0xEB, 0xE9, 0x42, 0x16,
 565                         0xE7, 0x87, 0xA3, 0xEF
 566                 },
 567                 .len = 20,
 568                 .truncated_len = 12
 569         }
 570 };
 571
 572 /* AES128-CTR-SHA1 test vector (12-byte IV) */
 573 static const struct blockcipher_test_data aes_test_data_1_IV_12_bytes = {
 574         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CTR,
 575         .cipher_key = {
 576                 .data = {
 577                         0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
 578                         0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
 579                 },
 580                 .len = 16
 581         },
 582         .iv = {
 583                 .data = {
 584                         0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
 585                         0xF8, 0xF9, 0xFA, 0xFB
 586                 },
 587                 .len = 12
 588         },
 589         .plaintext = {
 590                 .data = plaintext_aes128ctr,
 591                 .len = 64
 592         },
 593         .ciphertext = {
 594                 .data = ciphertext64_aes128ctr_IV_12bytes,
 595                 .len = 64
 596         },
 597         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
 598         .auth_key = {
 599                 .data = {
 600                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 601                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 602                         0xDE, 0xF4, 0xDE, 0xAD
 603                 },
 604                 .len = 20
 605         },
 606         .digest = {
 607                 .data = {
 608                         0x5C, 0x34, 0x6B, 0xE4, 0x9A, 0x7F, 0x4A, 0xC3,
 609                         0x82, 0xBE, 0xA0, 0x12, 0xD1, 0xF0, 0x15, 0xFA,
 610                         0xCF, 0xC8, 0x7F, 0x60
 611                 },
 612                 .len = 20,
 613                 .truncated_len = 12
 614         }
 615 };
 616
 617 /** AES-192-CTR XCBC test vector (12-byte IV) */
 618 static const struct blockcipher_test_data aes_test_data_2_IV_12_bytes = {
 619         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CTR,
 620         .cipher_key = {
 621                 .data = {
 622                         0xCB, 0xC5, 0xED, 0x5B, 0xE7, 0x7C, 0xBD, 0x8C,
 623                         0x50, 0xD9, 0x30, 0xF2, 0xB5, 0x6A, 0x0E, 0x5F,
 624                         0xAA, 0xAE, 0xAD, 0xA2, 0x1F, 0x49, 0x52, 0xD4
 625                 },
 626                 .len = 24
 627         },
 628         .iv = {
 629                 .data = {
 630                         0x3F, 0x69, 0xA8, 0xCD, 0xE8, 0xF0, 0xEF, 0x40,
 631                         0xB8, 0x7A, 0x4B, 0xED
 632                 },
 633                 .len = 12
 634         },
 635         .plaintext = {
 636                 .data = plaintext_aes192ctr,
 637                 .len = 64
 638         },
 639         .ciphertext = {
 640                 .data = ciphertext64_aes192ctr_IV_12bytes,
 641                 .len = 64
 642         },
 643         .auth_algo = RTE_CRYPTO_AUTH_AES_XCBC_MAC,
 644         .auth_key = {
 645                 .data = {
 646                         0x87, 0x61, 0x54, 0x53, 0xC4, 0x6D, 0xDD, 0x51,
 647                         0xE1, 0x9F, 0x86, 0x64, 0x39, 0x0A, 0xE6, 0x59
 648                 },
 649                 .len = 16
 650         },
 651         .digest = {
 652                 .data = {
 653                         0x0C, 0xA1, 0xA5, 0xAF, 0x3E, 0x41, 0xD2, 0xF4,
 654                         0x4C, 0x4C, 0xAB, 0x13
 655                 },
 656                 .len = 12,
 657                 .truncated_len = 12
 658         }
 659 };
 660
 661 /** AES-256-CTR SHA1 test vector (12-byte IV) */
 662 static const struct blockcipher_test_data aes_test_data_3_IV_12_bytes = {
 663         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CTR,
 664         .cipher_key = {
 665                 .data = {
 666                         0x60, 0x3D, 0xEB, 0x10, 0x15, 0xCA, 0x71, 0xBE,
 667                         0x2B, 0x73, 0xAE, 0xF0, 0x85, 0x7D, 0x77, 0x81,
 668                         0x1F, 0x35, 0x2C, 0x07, 0x3B, 0x61, 0x08, 0xD7,
 669                         0x2D, 0x98, 0x10, 0xA3, 0x09, 0x14, 0xDF, 0xF4
 670                 },
 671                 .len = 32
 672         },
 673         .iv = {
 674                 .data = {
 675                         0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
 676                         0xF8, 0xF9, 0xFA, 0xFB
 677                 },
 678                 .len = 12
 679         },
 680         .plaintext = {
 681                 .data = plaintext_aes256ctr,
 682                 .len = 64
 683         },
 684         .ciphertext = {
 685                 .data = ciphertext64_aes256ctr_IV_12bytes,
 686                 .len = 64
 687         },
 688         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
 689         .auth_key = {
 690                 .data = {
 691                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 692                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 693                         0xDE, 0xF4, 0xDE, 0xAD
 694                 },
 695                 .len = 20
 696         },
 697         .digest = {
 698                 .data = {
 699                         0x57, 0x9A, 0x52, 0x6E, 0x31, 0x17, 0x57, 0x49,
 700                         0xE7, 0xA1, 0x88, 0x6C, 0x2E, 0x36, 0x67, 0x63,
 701                         0x3F, 0x2D, 0xA3, 0xEF
 702                 },
 703                 .len = 20,
 704                 .truncated_len = 12
 705         }
 706 };
 707 /** AES-128-CBC SHA1 test vector */
 708 static const struct blockcipher_test_data aes_test_data_4 = {
 709         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
 710         .cipher_key = {
 711                 .data = {
 712                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
 713                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
 714                 },
 715                 .len = 16
 716         },
 717         .iv = {
 718                 .data = {
 719                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 720                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
 721                 },
 722                 .len = 16
 723         },
 724         .plaintext = {
 725                 .data = plaintext_aes_common,
 726                 .len = 512
 727         },
 728         .ciphertext = {
 729                 .data = ciphertext512_aes128cbc,
 730                 .len = 512
 731         },
 732         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
 733         .auth_key = {
 734                 .data = {
 735                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 736                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 737                         0xDE, 0xF4, 0xDE, 0xAD
 738                 },
 739                 .len = 20
 740         },
 741         .digest = {
 742                 .data = {
 743                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
 744                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
 745                         0x18, 0x8C, 0x1D, 0x32
 746                 },
 747                 .len = 20,
 748                 .truncated_len = 12
 749         }
 750 };
 751
 752 /** AES-128-CBC SHA256 test vector */
 753 static const struct blockcipher_test_data aes_test_data_5 = {
 754         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
 755         .cipher_key = {
 756                 .data = {
 757                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
 758                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
 759                 },
 760                 .len = 16
 761         },
 762         .iv = {
 763                 .data = {
 764                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 765                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
 766                 },
 767                 .len = 16
 768         },
 769         .plaintext = {
 770                 .data = plaintext_aes_common,
 771                 .len = 512
 772         },
 773         .ciphertext = {
 774                 .data = ciphertext512_aes128cbc,
 775                 .len = 512
 776         },
 777         .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC,
 778         .auth_key = {
 779                 .data = {
 780                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
 781                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
 782                         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
 783                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60
 784                 },
 785                 .len = 32
 786         },
 787         .digest = {
 788                 .data = {
 789                         0xC8, 0x57, 0x57, 0x31, 0x03, 0xE0, 0x03, 0x55,
 790                         0x07, 0xC8, 0x9E, 0x7F, 0x48, 0x9A, 0x61, 0x9A,
 791                         0x68, 0xEE, 0x03, 0x0E, 0x71, 0x75, 0xC7, 0xF4,
 792                         0x2E, 0x45, 0x26, 0x32, 0x7C, 0x12, 0x15, 0x15
 793                 },
 794                 .len = 32,
 795                 .truncated_len = 16
 796         }
 797 };
 798
 799 /** AES-128-CBC SHA512 test vector */
 800 static const struct blockcipher_test_data aes_test_data_6 = {
 801         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
 802         .cipher_key = {
 803                 .data = {
 804                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
 805                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
 806                 },
 807                 .len = 16
 808         },
 809         .iv = {
 810                 .data = {
 811                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 812                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
 813                 },
 814                 .len = 16
 815         },
 816         .plaintext = {
 817                 .data = plaintext_aes_common,
 818                 .len = 512
 819         },
 820         .ciphertext = {
 821                 .data = ciphertext512_aes128cbc,
 822                 .len = 512
 823         },
 824         .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC,
 825         .auth_key = {
 826                 .data = {
 827                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
 828                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
 829                         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
 830                         0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
 831                         0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
 832                         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
 833                         0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
 834                         0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
 835                 },
 836                 .len = 64
 837         },
 838         .digest = {
 839                 .data = {
 840                         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
 841                         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
 842                         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
 843                         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
 844                         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
 845                         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
 846                         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
 847                         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A
 848                 },
 849                 .len = 64,
 850                 .truncated_len = 32
 851         }
 852 };
 853
 854 /** AES-128-CBC XCBC test vector */
 855 static const struct blockcipher_test_data aes_test_data_7 = {
 856         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
 857         .cipher_key = {
 858                 .data = {
 859                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
 860                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
 861                 },
 862                 .len = 16
 863         },
 864         .iv = {
 865                 .data = {
 866                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 867                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
 868                 },
 869                 .len = 16
 870         },
 871         .plaintext = {
 872                 .data = plaintext_aes_common,
 873                 .len = 512
 874         },
 875         .ciphertext = {
 876                 .data = ciphertext512_aes128cbc,
 877                 .len = 512
 878         },
 879         .auth_algo = RTE_CRYPTO_AUTH_AES_XCBC_MAC,
 880         .auth_key = {
 881                 .data = {
 882                         0x87, 0x61, 0x54, 0x53, 0xC4, 0x6D, 0xDD, 0x51,
 883                         0xE1, 0x9F, 0x86, 0x64, 0x39, 0x0A, 0xE6, 0x59
 884                 },
 885                 .len = 16
 886         },
 887         .digest = {
 888                 .data = {
 889                         0xE0, 0xAC, 0x9A, 0xC4, 0x22, 0x64, 0x35, 0x89,
 890                         0x77, 0x1D, 0x8B, 0x75
 891                 },
 892                 .len = 12,
 893                 .truncated_len = 12
 894         }
 895 };
 896
 897 /** AES-128-CBC SHA224 test vector */
 898 static const struct blockcipher_test_data aes_test_data_8 = {
 899         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
 900         .cipher_key = {
 901                 .data = {
 902                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
 903                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
 904                 },
 905                 .len = 16
 906         },
 907         .iv = {
 908                 .data = {
 909                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 910                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
 911                 },
 912                 .len = 16
 913         },
 914         .plaintext = {
 915                 .data = plaintext_aes_common,
 916                 .len = 512
 917         },
 918         .ciphertext = {
 919                 .data = ciphertext512_aes128cbc,
 920                 .len = 512
 921         },
 922         .auth_algo = RTE_CRYPTO_AUTH_SHA224_HMAC,
 923         .auth_key = {
 924                 .data = {
 925                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
 926                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
 927                         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
 928                         0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
 929                         0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
 930                         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
 931                         0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
 932                         0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
 933                 },
 934                 .len = 64
 935         },
 936         .digest = {
 937                 .data = {
 938                         0xA3, 0xCA, 0xC7, 0x1D, 0xA8, 0x61, 0x30, 0x98,
 939                         0x3B, 0x8F, 0x01, 0x19, 0xAE, 0x8D, 0xBD, 0x34,
 940                         0x40, 0x63, 0xA8, 0x2F, 0xDF, 0x85, 0x2B, 0x7F,
 941                         0x63, 0x7C, 0xDD, 0xB7
 942                 },
 943                 .len = 28,
 944                 .truncated_len = 14
 945         }
 946 };
 947
 948 /** AES-128-CBC SHA384 test vector */
 949 static const struct blockcipher_test_data aes_test_data_9 = {
 950         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
 951         .cipher_key = {
 952                 .data = {
 953                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
 954                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
 955                 },
 956                 .len = 16
 957         },
 958         .iv = {
 959                 .data = {
 960                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 961                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
 962                 },
 963                 .len = 16
 964         },
 965         .plaintext = {
 966                 .data = plaintext_aes_common,
 967                 .len = 512
 968         },
 969         .ciphertext = {
 970                 .data = ciphertext512_aes128cbc,
 971                 .len = 512
 972         },
 973         .auth_algo = RTE_CRYPTO_AUTH_SHA384_HMAC,
 974         .auth_key = {
 975                 .data = {
 976                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
 977                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
 978                         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
 979                         0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
 980                         0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
 981                         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
 982                         0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
 983                         0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60,
 984                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
 985                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
 986                         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
 987                         0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
 988                         0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
 989                         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
 990                         0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
 991                         0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
 992                 },
 993                 .len = 128
 994         },
 995         .digest = {
 996                 .data = {
 997                         0x23, 0x60, 0xC8, 0xB1, 0x2D, 0x6C, 0x1E, 0x72,
 998                         0x25, 0xAB, 0xF9, 0xC3, 0x9A, 0xA9, 0x4F, 0x8C,
 999                         0x56, 0x38, 0x65, 0x0E, 0x74, 0xD5, 0x45, 0x9D,
1000                         0xA3, 0xFD, 0x7E, 0x6D, 0x9E, 0x74, 0x88, 0x9D,
1001                         0xA7, 0x12, 0x9D, 0xD8, 0x81, 0x3C, 0x86, 0x2F,
1002                         0x4D, 0xF9, 0x6F, 0x0A, 0xB0, 0xC9, 0xEB, 0x0B
1003                 },
1004                 .len = 48,
1005                 .truncated_len = 24
1006         }
1007 };
1008
1009 static const uint8_t ciphertext512_aes192cbc[] = {
1010         0x45, 0xEE, 0x9A, 0xEA, 0x3C, 0x03, 0xFC, 0x4C,
1011         0x84, 0x36, 0xB0, 0xDA, 0xB0, 0xDC, 0xF3, 0x5B,
1012         0x75, 0xA7, 0xBE, 0x0E, 0xC0, 0x8D, 0x6C, 0xF8,
1013         0xC1, 0x0F, 0xD0, 0x35, 0x1D, 0x82, 0xAE, 0x7C,
1014         0x57, 0xC5, 0x7A, 0x55, 0x87, 0x1B, 0xD4, 0x03,
1015         0x0A, 0x64, 0xC9, 0xE0, 0xF4, 0xC7, 0x6F, 0x57,
1016         0x52, 0xC6, 0x73, 0xBA, 0x84, 0x0B, 0x5B, 0x89,
1017         0x21, 0xD2, 0x9B, 0x88, 0x68, 0xF5, 0xA9, 0x7F,
1018         0x3F, 0x49, 0xEB, 0xF4, 0xD4, 0x52, 0xD2, 0x64,
1019         0x80, 0xB2, 0x53, 0xDA, 0x19, 0xF6, 0x10, 0x24,
1020         0x23, 0x26, 0x7A, 0x7C, 0x07, 0x57, 0x4B, 0x0E,
1021         0x58, 0x49, 0x61, 0xD1, 0xDC, 0x9A, 0x32, 0x6B,
1022         0x0F, 0x43, 0x9E, 0x4D, 0xB4, 0x07, 0x4E, 0xB3,
1023         0x51, 0x74, 0xDE, 0x29, 0xBC, 0x98, 0xF9, 0xDF,
1024         0x78, 0x9A, 0x18, 0x9C, 0xD6, 0x7A, 0x55, 0x7C,
1025         0xE6, 0x1D, 0x5C, 0x1A, 0x99, 0xD2, 0xC3, 0x7B,
1026         0x9F, 0x96, 0x74, 0x2D, 0xE0, 0xEF, 0xD1, 0xE3,
1027         0x08, 0x9F, 0xAF, 0xE6, 0xED, 0xCA, 0xE1, 0xEA,
1028         0x23, 0x6F, 0x7C, 0x81, 0xA8, 0xC0, 0x5B, 0x8B,
1029         0x53, 0x90, 0x51, 0x2D, 0x0F, 0xF6, 0x7D, 0xA7,
1030         0x1C, 0xBD, 0x83, 0x84, 0x54, 0xA4, 0x15, 0xFB,
1031         0x3E, 0x25, 0xA7, 0x3A, 0x0A, 0x73, 0xD9, 0x88,
1032         0x6F, 0x80, 0x78, 0x95, 0x7F, 0x60, 0xAA, 0x86,
1033         0x8A, 0xFC, 0xDF, 0xC1, 0xCB, 0xDE, 0xBB, 0x25,
1034         0x52, 0x20, 0xC6, 0x79, 0xD4, 0x0F, 0x25, 0xE7,
1035         0xDB, 0xB2, 0x17, 0xA4, 0x6F, 0x3C, 0x6F, 0x91,
1036         0xF6, 0x44, 0x1E, 0xB6, 0x85, 0xBC, 0x7A, 0x14,
1037         0x10, 0x72, 0xBD, 0x16, 0x63, 0x39, 0x9E, 0x7B,
1038         0x84, 0x5B, 0x17, 0x61, 0xB1, 0x5D, 0x82, 0x0B,
1039         0x6D, 0x37, 0xD7, 0x79, 0xB8, 0x24, 0x91, 0x30,
1040         0x82, 0x91, 0x02, 0xB1, 0x18, 0x4B, 0xE0, 0xF4,
1041         0x13, 0x1B, 0xB2, 0x4C, 0xDA, 0xB8, 0x99, 0x96,
1042         0x83, 0x2F, 0xBE, 0x53, 0x8D, 0xDE, 0xFA, 0xAD,
1043         0xF6, 0x5C, 0xDB, 0xE5, 0x66, 0x26, 0x8F, 0x13,
1044         0x2B, 0x76, 0x47, 0x73, 0xDE, 0x1A, 0x74, 0xA6,
1045         0x30, 0xAF, 0x42, 0xA0, 0xE5, 0xD2, 0x8F, 0xC2,
1046         0xED, 0x3E, 0x9E, 0x29, 0x54, 0x3C, 0xDE, 0x9F,
1047         0x5D, 0x30, 0x2B, 0x63, 0xFB, 0xE3, 0xB1, 0x07,
1048         0xEE, 0x74, 0x4A, 0xAF, 0xB1, 0x20, 0x8D, 0xEC,
1049         0xE6, 0x78, 0x16, 0x8D, 0xA4, 0x6E, 0x34, 0x7D,
1050         0x47, 0xFB, 0x0B, 0xC1, 0x32, 0xD7, 0x0D, 0x6C,
1051         0x6F, 0x93, 0x9C, 0x5E, 0xEF, 0x1F, 0x9C, 0x45,
1052         0x80, 0x6B, 0x74, 0xA6, 0x81, 0xF2, 0xF6, 0xFA,
1053         0xAA, 0x9D, 0x4F, 0xCA, 0xB5, 0x90, 0x59, 0xB0,
1054         0x3B, 0xF2, 0xF0, 0x75, 0xFD, 0x8A, 0xD8, 0x97,
1055         0x65, 0x88, 0x56, 0x4C, 0x44, 0xDF, 0x73, 0xF7,
1056         0x56, 0x9C, 0x48, 0x7E, 0xB0, 0x1F, 0x1D, 0x7D,
1057         0x6A, 0x11, 0xF5, 0xC2, 0xF4, 0x17, 0xEF, 0x58,
1058         0xD8, 0x2A, 0xAF, 0x56, 0x2F, 0xCF, 0xEC, 0xA4,
1059         0x58, 0x8B, 0x60, 0xCE, 0xD4, 0x0F, 0x9C, 0x21,
1060         0xEC, 0x3E, 0x74, 0x7B, 0x81, 0x3D, 0x69, 0xC6,
1061         0x5E, 0x12, 0x83, 0xE9, 0xEF, 0x81, 0x58, 0x36,
1062         0x6A, 0x60, 0x0F, 0x54, 0x28, 0x11, 0xF9, 0x64,
1063         0x36, 0xAD, 0x79, 0xF5, 0x1C, 0x74, 0xD0, 0xC3,
1064         0x7B, 0x61, 0xE1, 0x92, 0xB0, 0x13, 0x91, 0x87,
1065         0x32, 0x1F, 0xF2, 0x5A, 0xDA, 0x25, 0x69, 0xEB,
1066         0xD7, 0x32, 0x7F, 0xF5, 0x23, 0x21, 0x54, 0x47,
1067         0x7B, 0x1B, 0x33, 0xB0, 0x3D, 0xF6, 0xE2, 0x7E,
1068         0x3E, 0xA2, 0x9E, 0xCA, 0x48, 0x0B, 0x4A, 0x29,
1069         0x81, 0xD4, 0x4E, 0xD5, 0x69, 0xFB, 0xCD, 0x37,
1070         0x8A, 0xC1, 0x5B, 0x50, 0xFF, 0xB5, 0x7D, 0x43,
1071         0x0F, 0xAE, 0xA6, 0xC2, 0xE5, 0x8F, 0x45, 0xB2,
1072         0x85, 0x99, 0x02, 0xA2, 0x9B, 0xBE, 0x90, 0x43,
1073         0x4F, 0x2F, 0x50, 0xE2, 0x77, 0x62, 0xD9, 0xCC
1074 };
1075
1076 /** AES-192-CBC test vector */
1077 static const struct blockcipher_test_data aes_test_data_10 = {
1078         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
1079         .cipher_key = {
1080                 .data = {
1081                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1082                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
1083                         0xD4, 0xC3, 0xA3, 0xAA, 0x33, 0x62, 0x61, 0xE0
1084                 },
1085                 .len = 24
1086         },
1087         .iv = {
1088                 .data = {
1089                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1090                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
1091                 },
1092                 .len = 16
1093         },
1094         .plaintext = {
1095                 .data = plaintext_aes_common,
1096                 .len = 512
1097         },
1098         .ciphertext = {
1099                 .data = ciphertext512_aes192cbc,
1100                 .len = 512
1101         }
1102 };
1103
1104 static const uint8_t ciphertext512_aes256cbc[] = {
1105         0xF3, 0xDD, 0xF0, 0x0B, 0xFF, 0xA2, 0x6A, 0x04,
1106         0xBE, 0xDA, 0x52, 0xA6, 0xFE, 0x6B, 0xA6, 0xA7,
1107         0x48, 0x1D, 0x7D, 0x98, 0x65, 0xDB, 0xEF, 0x06,
1108         0x26, 0xB5, 0x8E, 0xEB, 0x05, 0x0E, 0x77, 0x98,
1109         0x17, 0x8E, 0xD0, 0xD4, 0x7B, 0x92, 0x8F, 0x5C,
1110         0xD0, 0x74, 0x5C, 0xA8, 0x4B, 0x54, 0xB6, 0x2F,
1111         0x83, 0x72, 0x2C, 0xFF, 0x72, 0xE9, 0xE4, 0x15,
1112         0x4C, 0x32, 0xAF, 0xC8, 0xC9, 0x89, 0x3C, 0x6E,
1113         0x31, 0xD5, 0xC0, 0x16, 0xC0, 0x31, 0x7D, 0x11,
1114         0xAB, 0xCB, 0xDE, 0xD2, 0xD6, 0xAA, 0x76, 0x5E,
1115         0xBA, 0xF6, 0xE2, 0x92, 0xCB, 0x86, 0x07, 0xFA,
1116         0xD4, 0x9E, 0x83, 0xED, 0xFD, 0xB8, 0x70, 0x54,
1117         0x6B, 0xBE, 0xEC, 0x72, 0xDD, 0x28, 0x5E, 0x95,
1118         0x78, 0xA5, 0x28, 0x43, 0x3D, 0x6D, 0xB1, 0xD9,
1119         0x69, 0x1F, 0xC9, 0x66, 0x0E, 0x32, 0x44, 0x08,
1120         0xD2, 0xAE, 0x2C, 0x43, 0xF2, 0xD0, 0x7D, 0x26,
1121         0x70, 0xE5, 0xA1, 0xCA, 0x37, 0xE9, 0x7D, 0xC7,
1122         0xA3, 0xFA, 0x81, 0x91, 0x64, 0xAA, 0x64, 0x91,
1123         0x9A, 0x95, 0x2D, 0xC9, 0xF9, 0xCE, 0xFE, 0x9F,
1124         0xC4, 0xD8, 0x81, 0xBE, 0x57, 0x84, 0xC5, 0x02,
1125         0xDB, 0x30, 0xC1, 0xD9, 0x0E, 0xA0, 0xA6, 0x00,
1126         0xD6, 0xF3, 0x52, 0x7E, 0x0D, 0x23, 0x6B, 0x2B,
1127         0x34, 0x99, 0x1F, 0x70, 0x27, 0x6D, 0x58, 0x84,
1128         0x93, 0x77, 0xB8, 0x3E, 0xF1, 0x71, 0x58, 0x42,
1129         0x8B, 0x2B, 0xC8, 0x6D, 0x05, 0x84, 0xFF, 0x4E,
1130         0x85, 0xEF, 0x4A, 0x9D, 0x91, 0x6A, 0xD5, 0xE1,
1131         0xAF, 0x01, 0xEB, 0x83, 0x8F, 0x23, 0x7C, 0x7F,
1132         0x12, 0x91, 0x05, 0xF0, 0x4E, 0xD9, 0x17, 0x62,
1133         0x75, 0xBB, 0xAC, 0x97, 0xEE, 0x3B, 0x4E, 0xC7,
1134         0xE5, 0x92, 0xF8, 0x9D, 0x4C, 0xF9, 0xEE, 0x55,
1135         0x18, 0xBB, 0xCC, 0xB4, 0xF2, 0x59, 0xB9, 0xFC,
1136         0x7A, 0x0F, 0x98, 0xD4, 0x8B, 0xFE, 0xF7, 0x83,
1137         0x46, 0xE2, 0x83, 0x33, 0x3E, 0x95, 0x8D, 0x17,
1138         0x1E, 0x85, 0xF8, 0x8C, 0x51, 0xB0, 0x6C, 0xB5,
1139         0x5E, 0x95, 0xBA, 0x4B, 0x69, 0x1B, 0x48, 0x69,
1140         0x0B, 0x8F, 0xA5, 0x18, 0x13, 0xB9, 0x77, 0xD1,
1141         0x80, 0x32, 0x32, 0x6D, 0x53, 0xA1, 0x95, 0x40,
1142         0x96, 0x8A, 0xCC, 0xA3, 0x69, 0xF8, 0x9F, 0xB5,
1143         0x8E, 0xD2, 0x68, 0x07, 0x4F, 0xA7, 0xEC, 0xF8,
1144         0x20, 0x21, 0x58, 0xF8, 0xD8, 0x9E, 0x5F, 0x40,
1145         0xBA, 0xB9, 0x76, 0x57, 0x3B, 0x17, 0xAD, 0xEE,
1146         0xCB, 0xDF, 0x07, 0xC1, 0xDF, 0x66, 0xA8, 0x0D,
1147         0xC2, 0xCE, 0x8F, 0x79, 0xC3, 0x32, 0xE0, 0x8C,
1148         0xFE, 0x5A, 0xF3, 0x55, 0x27, 0x73, 0x6F, 0xA1,
1149         0x54, 0xC6, 0xFC, 0x28, 0x9D, 0xBE, 0x97, 0xB9,
1150         0x54, 0x97, 0x72, 0x3A, 0x61, 0xAF, 0x6F, 0xDE,
1151         0xF8, 0x0E, 0xBB, 0x6B, 0x96, 0x84, 0xDD, 0x9B,
1152         0x62, 0xBA, 0x47, 0xB5, 0xC9, 0x3B, 0x4E, 0x8C,
1153         0x78, 0x2A, 0xCC, 0x0A, 0x69, 0x54, 0x25, 0x5E,
1154         0x8B, 0xAC, 0x56, 0xD9, 0xFE, 0x48, 0xBA, 0xCE,
1155         0xA9, 0xCE, 0xA6, 0x1D, 0xBF, 0x3E, 0x3C, 0x66,
1156         0x40, 0x71, 0x79, 0xAD, 0x5B, 0x26, 0xAD, 0xBE,
1157         0x58, 0x13, 0x64, 0x60, 0x7C, 0x05, 0xFC, 0xE3,
1158         0x51, 0x7A, 0xF2, 0xCC, 0x54, 0x16, 0x2C, 0xA4,
1159         0xCE, 0x5F, 0x59, 0x12, 0x77, 0xEB, 0xD9, 0x23,
1160         0xE3, 0x86, 0xFB, 0xD7, 0x48, 0x76, 0x9D, 0xE3,
1161         0x89, 0x87, 0x39, 0xFA, 0x7B, 0x21, 0x0B, 0x76,
1162         0xB2, 0xED, 0x1C, 0x27, 0x4B, 0xD5, 0x27, 0x05,
1163         0x8C, 0x7D, 0x58, 0x6C, 0xCA, 0xA5, 0x54, 0x9A,
1164         0x0F, 0xCB, 0xE9, 0x88, 0x31, 0xAD, 0x49, 0xEE,
1165         0x38, 0xFB, 0xC9, 0xFB, 0xB4, 0x7A, 0x00, 0x58,
1166         0x20, 0x32, 0xD3, 0x53, 0x5A, 0xDD, 0x74, 0x95,
1167         0x60, 0x59, 0x09, 0xAE, 0x7E, 0xEC, 0x74, 0xA3,
1168         0xB7, 0x1C, 0x6D, 0xF2, 0xAE, 0x79, 0xA4, 0x7C
1169 };
1170
1171 /** AES-256-CBC test vector */
1172 static const struct blockcipher_test_data aes_test_data_11 = {
1173         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
1174         .cipher_key = {
1175                 .data = {
1176                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1177                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
1178                         0xD4, 0xC3, 0xA3, 0xAA, 0x33, 0x62, 0x61, 0xE0,
1179                         0x37, 0x07, 0xB8, 0x23, 0xA2, 0xA3, 0xB5, 0x8D
1180                 },
1181                 .len = 32
1182         },
1183         .iv = {
1184                 .data = {
1185                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1186                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
1187                 },
1188                 .len = 16
1189         },
1190         .plaintext = {
1191                 .data = plaintext_aes_common,
1192                 .len = 512
1193         },
1194         .ciphertext = {
1195                 .data = ciphertext512_aes256cbc,
1196                 .len = 512
1197         }
1198 };
1199
1200 /** AES-128-CBC SHA256 HMAC test vector (160 bytes) */
1201 static const struct blockcipher_test_data aes_test_data_12 = {
1202         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
1203         .cipher_key = {
1204                 .data = {
1205                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1206                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
1207                 },
1208                 .len = 16
1209         },
1210         .iv = {
1211                 .data = {
1212                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1213                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
1214                 },
1215                 .len = 16
1216         },
1217         .plaintext = {
1218                 .data = plaintext_aes_common,
1219                 .len = 160
1220         },
1221         .ciphertext = {
1222                 .data = ciphertext512_aes128cbc,
1223                 .len = 160
1224         },
1225         .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC,
1226         .auth_key = {
1227                 .data = {
1228                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1229                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1230                         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1231                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60
1232                 },
1233                 .len = 32
1234         },
1235         .digest = {
1236                 .data = {
1237                         0x92, 0xEC, 0x65, 0x9A, 0x52, 0xCC, 0x50, 0xA5,
1238                         0xEE, 0x0E, 0xDF, 0x1E, 0xA4, 0xC9, 0xC1, 0x04,
1239                         0xD5, 0xDC, 0x78, 0x90, 0xF4, 0xE3, 0x35, 0x62,
1240                         0xAD, 0x95, 0x45, 0x28, 0x5C, 0xF8, 0x8C, 0x0B
1241                 },
1242                 .len = 32,
1243                 .truncated_len = 16
1244         }
1245 };
1246
1247 /** AES-128-CBC SHA1 HMAC test vector (160 bytes) */
1248 static const struct blockcipher_test_data aes_test_data_13 = {
1249         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
1250         .cipher_key = {
1251                 .data = {
1252                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1253                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
1254                 },
1255                 .len = 16
1256         },
1257         .iv = {
1258                 .data = {
1259                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1260                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
1261                 },
1262                 .len = 16
1263         },
1264         .plaintext = {
1265                 .data = plaintext_aes_common,
1266                 .len = 160
1267         },
1268         .ciphertext = {
1269                 .data = ciphertext512_aes128cbc,
1270                 .len = 160
1271         },
1272         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
1273         .auth_key = {
1274                 .data = {
1275                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
1276                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
1277                         0xDE, 0xF4, 0xDE, 0xAD
1278                 },
1279                 .len = 20
1280         },
1281         .digest = {
1282                 .data = {
1283                         0x4F, 0x16, 0xEA, 0xF7, 0x4A, 0x88, 0xD3, 0xE0,
1284                         0x0E, 0x12, 0x8B, 0xE7, 0x05, 0xD0, 0x86, 0x48,
1285                         0x22, 0x43, 0x30, 0xA7
1286                 },
1287                 .len = 20,
1288                 .truncated_len = 12
1289         }
1290 };
1291
1292 /** XTS-AES-128 test vector (2 keys * 128 bit) */
1293 static const uint8_t plaintext_aes128xts_16bytes[] = {
1294         0xEB, 0xAB, 0xCE, 0x95, 0xB1, 0x4D, 0x3C, 0x8D,
1295         0x6F, 0xB3, 0x50, 0x39, 0x07, 0x90, 0x31, 0x1C
1296 };
1297 static const uint8_t ciphertext_aes128xts_16bytes[] = {
1298         0x77, 0x8A, 0xE8, 0xB4, 0x3C, 0xB9, 0x8D, 0x5A,
1299         0x82, 0x50, 0x81, 0xD5, 0xBE, 0x47, 0x1C, 0x63
1300 };
1301 static const struct
1302 blockcipher_test_data aes_test_data_xts_key_32_pt_16 = {
1303         .crypto_algo = RTE_CRYPTO_CIPHER_AES_XTS,
1304         .cipher_key = {
1305                 .data = {
1306                         0xA1, 0xB9, 0x0C, 0xBA, 0x3F, 0x06, 0xAC, 0x35,
1307                         0x3B, 0x2C, 0x34, 0x38, 0x76, 0x08, 0x17, 0x62,
1308                         0x09, 0x09, 0x23, 0x02, 0x6E, 0x91, 0x77, 0x18,
1309                         0x15, 0xF2, 0x9D, 0xAB, 0x01, 0x93, 0x2F, 0x2F
1310                 },
1311                 .len = 32
1312         },
1313         .iv = {
1314                 .data = {
1315                         0x4F, 0xAE, 0xF7, 0x11, 0x7C, 0xDA, 0x59, 0xC6,
1316                         0x6E, 0x4B, 0x92, 0x01, 0x3E, 0x76, 0x8A, 0xD5
1317                 },
1318                 .len = 16
1319         },
1320         .plaintext = {
1321                 .data = plaintext_aes128xts_16bytes,
1322                 .len = 16
1323         },
1324         .ciphertext = {
1325                 .data = ciphertext_aes128xts_16bytes,
1326                 .len = 16
1327         }
1328 };
1329 static const uint8_t plaintext_aes128xts_32bytes[] = {
1330         0xB0, 0x4D, 0x84, 0xDA, 0x85, 0x6B, 0x9A, 0x59,
1331         0xCE, 0x2D, 0x62, 0x67, 0x46, 0xF6, 0x89, 0xA8,
1332         0x05, 0x1D, 0xAC, 0xD6, 0xBC, 0xE3, 0xB9, 0x90,
1333         0xAA, 0x90, 0x1E, 0x40, 0x30, 0x64, 0x88, 0x79
1334 };
1335 static const uint8_t ciphertext_aes128xts_32bytes[] = {
1336         0xF9, 0x41, 0x03, 0x9E, 0xBA, 0xB8, 0xCA, 0xC3,
1337         0x9D, 0x59, 0x24, 0x7C, 0xBB, 0xCB, 0x4D, 0x81,
1338         0x6C, 0x72, 0x6D, 0xAE, 0xD1, 0x15, 0x77, 0x69,
1339         0x2C, 0x55, 0xE4, 0xAC, 0x6D, 0x3E, 0x68, 0x20
1340 };
1341 static const struct
1342 blockcipher_test_data aes_test_data_xts_key_32_pt_32 = {
1343         .crypto_algo = RTE_CRYPTO_CIPHER_AES_XTS,
1344         .cipher_key = {
1345                 .data = {
1346                         0x78, 0x3A, 0x83, 0xEC, 0x52, 0xA2, 0x74, 0x05,
1347                         0xDF, 0xF9, 0xDE, 0x4C, 0x57, 0xF9, 0xC9, 0x79,
1348                         0xB3, 0x60, 0xB6, 0xA5, 0xDF, 0x88, 0xD6, 0x7E,
1349                         0xC1, 0xA0, 0x52, 0xE6, 0xF5, 0x82, 0xA7, 0x17
1350                 },
1351                 .len = 32
1352         },
1353         .iv = {
1354                 .data = {
1355                         0x88, 0x6E, 0x97, 0x5B, 0x29, 0xBD, 0xF6, 0xF0,
1356                         0xC0, 0x1B, 0xB4, 0x7F, 0x61, 0xF6, 0xF0, 0xF5
1357                 },
1358                 .len = 16
1359         },
1360         .plaintext = {
1361                 .data = plaintext_aes128xts_32bytes,
1362                 .len = 32
1363         },
1364         .ciphertext = {
1365                 .data = ciphertext_aes128xts_32bytes,
1366                 .len = 32
1367         }
1368 };
1369
1370 /** XTS-AES-256 test vector (2 keys * 256 bit) */
1371 /* Encryption */
1372 static const uint8_t plaintext_aes256xts_32bytes[] = {
1373         0x2E, 0xED, 0xEA, 0x52, 0xCD, 0x82, 0x15, 0xE1,
1374         0xAC, 0xC6, 0x47, 0xE8, 0x10, 0xBB, 0xC3, 0x64,
1375         0x2E, 0x87, 0x28, 0x7F, 0x8D, 0x2E, 0x57, 0xE3,
1376         0x6C, 0x0A, 0x24, 0xFB, 0xC1, 0x2A, 0x20, 0x2E
1377 };
1378 static const uint8_t ciphertext_aes256xts_32bytes[] = {
1379         0xCB, 0xAA, 0xD0, 0xE2, 0xF6, 0xCE, 0xA3, 0xF5,
1380         0x0B, 0x37, 0xF9, 0x34, 0xD4, 0x6A, 0x9B, 0x13,
1381         0x0B, 0x9D, 0x54, 0xF0, 0x7E, 0x34, 0xF3, 0x6A,
1382         0xF7, 0x93, 0xE8, 0x6F, 0x73, 0xC6, 0xD7, 0xDB
1383 };
1384 static const struct
1385 blockcipher_test_data aes_test_data_xts_key_64_pt_32 = {
1386         .crypto_algo = RTE_CRYPTO_CIPHER_AES_XTS,
1387         .cipher_key = {
1388                 .data = {
1389                         0x1E, 0xA6, 0x61, 0xC5, 0x8D, 0x94, 0x3A, 0x0E,
1390                         0x48, 0x01, 0xE4, 0x2F, 0x4B, 0x09, 0x47, 0x14,
1391                         0x9E, 0x7F, 0x9F, 0x8E, 0x3E, 0x68, 0xD0, 0xC7,
1392                         0x50, 0x52, 0x10, 0xBD, 0x31, 0x1A, 0x0E, 0x7C,
1393                         0xD6, 0xE1, 0x3F, 0xFD, 0xF2, 0x41, 0x8D, 0x8D,
1394                         0x19, 0x11, 0xC0, 0x04, 0xCD, 0xA5, 0x8D, 0xA3,
1395                         0xD6, 0x19, 0xB7, 0xE2, 0xB9, 0x14, 0x1E, 0x58,
1396                         0x31, 0x8E, 0xEA, 0x39, 0x2C, 0xF4, 0x1B, 0x08
1397                 },
1398                 .len = 64
1399         },
1400         .iv = {
1401                 .data = {
1402                         0xAD, 0xF8, 0xD9, 0x26, 0x27, 0x46, 0x4A, 0xD2,
1403                         0xF0, 0x42, 0x8E, 0x84, 0xA9, 0xF8, 0x75, 0x64
1404                 },
1405                 .len = 16
1406         },
1407         .plaintext = {
1408                 .data = plaintext_aes256xts_32bytes,
1409                 .len = 32
1410         },
1411         .ciphertext = {
1412                 .data = ciphertext_aes256xts_32bytes,
1413                 .len = 32
1414         }
1415 };
1416 static const uint8_t plaintext_aes256xts_48bytes[] = {
1417         0xBB, 0xB2, 0x34, 0xDB, 0x01, 0xBE, 0x79, 0xD3,
1418         0xDC, 0x7D, 0xCF, 0x49, 0xBC, 0x53, 0xB8, 0xEF,
1419         0xC6, 0x2F, 0xE7, 0x17, 0x94, 0x39, 0x06, 0x1D,
1420         0x73, 0xA6, 0xB2, 0x0E, 0xDB, 0x9B, 0x7D, 0xA0,
1421         0x45, 0x0B, 0x19, 0xF0, 0x20, 0x82, 0x02, 0x09,
1422         0xAF, 0xE0, 0x81, 0x12, 0xAE, 0x4A, 0xFD, 0xD3
1423 };
1424 static const uint8_t ciphertext_aes256xts_48bytes[] = {
1425         0xCB, 0xF6, 0x88, 0x48, 0xC4, 0x20, 0x49, 0xEF,
1426         0xB1, 0x46, 0xE2, 0xD1, 0xE4, 0x11, 0x5F, 0x62,
1427         0xE4, 0xFA, 0xA4, 0xEF, 0xFF, 0x19, 0x8F, 0x1A,
1428         0x0A, 0xA0, 0xC9, 0x8B, 0xA0, 0x2C, 0xC4, 0x4D,
1429         0xA3, 0x76, 0xD7, 0x62, 0xD6, 0x15, 0x1F, 0x23,
1430         0x45, 0x87, 0xBF, 0x12, 0x8B, 0x6A, 0x7F, 0xFA
1431 };
1432 static const struct
1433 blockcipher_test_data aes_test_data_xts_key_64_pt_48 = {
1434         .crypto_algo = RTE_CRYPTO_CIPHER_AES_XTS,
1435         .cipher_key = {
1436                 .data = {
1437                         0x7F, 0xB0, 0x92, 0x2F, 0xCE, 0x09, 0xED, 0xDD,
1438                         0x36, 0x65, 0xA1, 0x1F, 0x52, 0x35, 0xD5, 0x1E,
1439                         0xF7, 0x72, 0x06, 0xA7, 0xDE, 0x45, 0x47, 0x75,
1440                         0xB6, 0x9D, 0xCC, 0x54, 0x59, 0xAC, 0xDB, 0x24,
1441                         0xCC, 0xF0, 0x5C, 0x41, 0x5A, 0xF5, 0xAB, 0x8A,
1442                         0x06, 0x62, 0x3D, 0x19, 0x8D, 0x5B, 0x91, 0x85,
1443                         0x95, 0xA9, 0xDC, 0xAA, 0xF5, 0x39, 0x2E, 0xE7,
1444                         0x17, 0xC1, 0x04, 0x7F, 0x2F, 0x08, 0xF6, 0x2B
1445                 },
1446                 .len = 64
1447         },
1448         .iv = {
1449                 .data = {
1450                         0x8E, 0xA3, 0x63, 0x8B, 0x9D, 0x40, 0x62, 0xF1,
1451                         0x69, 0x19, 0x6F, 0xF4, 0x55, 0x5A, 0xD0, 0xAF
1452                 },
1453                 .len = 16
1454         },
1455         .plaintext = {
1456                 .data = plaintext_aes256xts_48bytes,
1457                 .len = 48
1458         },
1459         .ciphertext = {
1460                 .data = ciphertext_aes256xts_48bytes,
1461                 .len = 48
1462         }
1463 };
1464
1465 /* AES-DOCSIS-BPI test vectors */
1466
1467 /* Multiple of AES block size */
1468 static const struct blockcipher_test_data aes_test_data_docsis_1 = {
1469         .crypto_algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI,
1470         .cipher_key = {
1471                 .data = {
1472                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1473                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
1474                 },
1475                 .len = 16
1476         },
1477         .iv = {
1478                 .data = {
1479                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1480                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
1481                 },
1482                 .len = 16
1483         },
1484         .plaintext = {
1485                 .data = plaintext_aes_common,
1486                 .len = 512
1487         },
1488         .ciphertext = {
1489                 .data = ciphertext512_aes128cbc,
1490                 .len = 512
1491         }
1492 };
1493
1494 /* Less than AES block size */
1495 static const struct blockcipher_test_data aes_test_data_docsis_2 = {
1496         .crypto_algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI,
1497         .cipher_key = {
1498                 .data = {
1499                         0xE6, 0x60, 0x0F, 0xD8, 0x85, 0x2E, 0xF5, 0xAB,
1500                         0xE6, 0x60, 0x0F, 0xD8, 0x85, 0x2E, 0xF5, 0xAB
1501                 },
1502                 .len = 16
1503         },
1504         .iv = {
1505                 .data = {
1506                         0x81, 0x0E, 0x52, 0x8E, 0x1C, 0x5F, 0xDA, 0x1A,
1507                         0x81, 0x0E, 0x52, 0x8E, 0x1C, 0x5F, 0xDA, 0x1A
1508                 },
1509                 .len = 16
1510         },
1511         .plaintext = {
1512                 .data = plaintext_aes_docsis_bpi_cfb,
1513                 .len = 7
1514         },
1515         .ciphertext = {
1516                 .data = ciphertext_aes_docsis_bpi_cfb,
1517                 .len = 7
1518         }
1519 };
1520
1521 /* Not multiple of AES block size */
1522 static const struct blockcipher_test_data aes_test_data_docsis_3 = {
1523         .crypto_algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI,
1524         .cipher_key = {
1525                 .data = {
1526                         0xE6, 0x60, 0x0F, 0xD8, 0x85, 0x2E, 0xF5, 0xAB,
1527                         0xE6, 0x60, 0x0F, 0xD8, 0x85, 0x2E, 0xF5, 0xAB
1528                 },
1529                 .len = 16
1530         },
1531         .iv = {
1532                 .data = {
1533                         0x81, 0x0E, 0x52, 0x8E, 0x1C, 0x5F, 0xDA, 0x1A,
1534                         0x81, 0x0E, 0x52, 0x8E, 0x1C, 0x5F, 0xDA, 0x1A
1535                 },
1536                 .len = 16
1537         },
1538         .plaintext = {
1539                 .data = plaintext_aes_docsis_bpi_cbc_cfb,
1540                 .len = 19
1541         },
1542         .ciphertext = {
1543                 .data = ciphertext_aes_docsis_bpi_cbc_cfb,
1544                 .len = 19
1545         }
1546 };
1547
1548 /* Multiple of AES 256 block size */
1549 static const struct blockcipher_test_data aes_test_data_docsis_4 = {
1550         .crypto_algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI,
1551         .cipher_key = {
1552                 .data = {
1553                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1554                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
1555                         0xD4, 0xC3, 0xA3, 0xAA, 0x33, 0x62, 0x61, 0xE0,
1556                         0x37, 0x07, 0xB8, 0x23, 0xA2, 0xA3, 0xB5, 0x8D
1557                 },
1558                 .len = 32
1559         },
1560         .iv = {
1561                 .data = {
1562                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1563                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
1564                 },
1565                 .len = 16
1566         },
1567         .plaintext = {
1568                 .data = plaintext_aes_common,
1569                 .len = 512
1570         },
1571         .ciphertext = {
1572                 .data = ciphertext512_aes256cbc,
1573                 .len = 512
1574         }
1575 };
1576
1577 /* Less than AES 256 block size */
1578 static const struct blockcipher_test_data aes_test_data_docsis_5 = {
1579         .crypto_algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI,
1580         .cipher_key = {
1581                 .data = {
1582                         0xE6, 0x60, 0x0F, 0xD8, 0x85, 0x2E, 0xF5, 0xAB,
1583                         0xE6, 0x60, 0x0F, 0xD8, 0x85, 0x2E, 0xF5, 0xAB,
1584                         0xE6, 0x60, 0x0F, 0xD8, 0x85, 0x2E, 0xF5, 0xAB,
1585                         0xE6, 0x60, 0x0F, 0xD8, 0x85, 0x2E, 0xF5, 0xAB
1586                 },
1587                 .len = 32
1588         },
1589         .iv = {
1590                 .data = {
1591                         0x81, 0x0E, 0x52, 0x8E, 0x1C, 0x5F, 0xDA, 0x1A,
1592                         0x81, 0x0E, 0x52, 0x8E, 0x1C, 0x5F, 0xDA, 0x1A
1593                 },
1594                 .len = 16
1595         },
1596         .plaintext = {
1597                 .data = plaintext_aes_docsis_bpi_cfb,
1598                 .len = 7
1599         },
1600         .ciphertext = {
1601                 .data = ciphertext_aes256_docsis_bpi_cfb,
1602                 .len = 7
1603         }
1604 };
1605
1606 /* Not multiple of AES 256 block size */
1607 static const struct blockcipher_test_data aes_test_data_docsis_6 = {
1608         .crypto_algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI,
1609         .cipher_key = {
1610                 .data = {
1611                         0xE6, 0x60, 0x0F, 0xD8, 0x85, 0x2E, 0xF5, 0xAB,
1612                         0xE6, 0x60, 0x0F, 0xD8, 0x85, 0x2E, 0xF5, 0xAB,
1613                         0xE6, 0x60, 0x0F, 0xD8, 0x85, 0x2E, 0xF5, 0xAB,
1614                         0xE6, 0x60, 0x0F, 0xD8, 0x85, 0x2E, 0xF5, 0xAB
1615                 },
1616                 .len = 32
1617         },
1618         .iv = {
1619                 .data = {
1620                         0x81, 0x0E, 0x52, 0x8E, 0x1C, 0x5F, 0xDA, 0x1A,
1621                         0x81, 0x0E, 0x52, 0x8E, 0x1C, 0x5F, 0xDA, 0x1A
1622                 },
1623                 .len = 16
1624         },
1625         .plaintext = {
1626                 .data = plaintext_aes_docsis_bpi_cbc_cfb,
1627                 .len = 19
1628         },
1629         .ciphertext = {
1630                 .data = ciphertext_aes256_docsis_bpi_cbc_cfb,
1631                 .len = 19
1632         }
1633 };
1634
1635 static const uint8_t
1636 cipher_aescbc_offset_16[] = {
1637         0x57, 0x68, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6C,
1638         0x6F, 0x75, 0x73, 0x79, 0x20, 0x65, 0x61, 0x72,
1639         0x68, 0x2A, 0x6A, 0x82, 0xE0, 0x73, 0xC7, 0x51,
1640         0x81, 0xF4, 0x47, 0x27, 0x1A, 0xEF, 0x76, 0x15,
1641         0x1C, 0xE1, 0x38, 0x5F, 0xE1, 0x81, 0x77, 0xC7,
1642         0x8B, 0xF0, 0x69, 0xC3, 0x3C, 0x45, 0x1C, 0x0A,
1643         0xA3, 0x93, 0xBF, 0x60, 0x57, 0x88, 0xD2, 0xFF,
1644         0xE1, 0x8F, 0xC0, 0x64, 0x2C, 0x42, 0xC5, 0x22,
1645         0xE3, 0x5F, 0x71, 0x1F, 0xF7, 0x62, 0xA2, 0x7E,
1646         0x0D, 0x42, 0xD9, 0xE7, 0xF3, 0x10, 0xB0, 0xEE,
1647 };
1648
1649 /** AES-128-CBC SHA1 OOP test vector for swapping src/dst */
1650 static const struct blockcipher_test_data aes_test_data_14 = {
1651         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
1652         .cipher_key = {
1653                 .data = {
1654                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1655                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
1656                 },
1657                 .len = 16
1658         },
1659         .iv = {
1660                 .data = {
1661                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1662                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
1663                 },
1664                 .len = 16
1665         },
1666         .plaintext = {
1667                 .data = plaintext_aes_common,
1668                 .len = 80
1669         },
1670         .cipher_offset = 16,
1671         .auth_offset = 0,
1672         .ciphertext = {
1673                 .data = cipher_aescbc_offset_16,
1674                 .len = 80
1675         },
1676         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
1677         .auth_key = {
1678                 .data = {
1679                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
1680                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
1681                         0xDE, 0xF4, 0xDE, 0xAD
1682                 },
1683                 .len = 20
1684         },
1685         .digest = {
1686                 .data = {
1687                         0xCC, 0x15, 0x83, 0xF7, 0x23, 0x87, 0x96, 0xA7,
1688                         0x29, 0x34, 0x32, 0xE4, 0x4C, 0x06, 0xE8, 0xEB,
1689                         0x70, 0x72, 0x4B, 0xAD
1690                 },
1691                 .len = 20,
1692                 .truncated_len = 12
1693         }
1694 };
1695
1696 static const struct blockcipher_test_case aes_chain_test_cases[] = {
1697         {
1698                 .test_descr = "AES-128-CBC HMAC-SHA1 Decryption Digest "
1699                         "Verify OOP Offset",
1700                 .test_data = &aes_test_data_14,
1701                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1702                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
1703         },
1704                 {
1705                 .test_descr = "AES-128-CTR HMAC-SHA1 Encryption Digest",
1706                 .test_data = &aes_test_data_1,
1707                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1708         },
1709         {
1710                 .test_descr = "AES-128-CTR HMAC-SHA1 Decryption Digest "
1711                         "Verify",
1712                 .test_data = &aes_test_data_1,
1713                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1714         },
1715         {
1716                 .test_descr = "AES-192-CTR XCBC Encryption Digest",
1717                 .test_data = &aes_test_data_2,
1718                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1719         },
1720         {
1721                 .test_descr = "AES-192-CTR XCBC Decryption Digest Verify",
1722                 .test_data = &aes_test_data_2,
1723                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1724         },
1725         {
1726                 .test_descr = "AES-192-CTR XCBC Decryption Digest Verify "
1727                                 "Scatter Gather",
1728                 .test_data = &aes_test_data_2,
1729                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1730                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_SG |
1731                         BLOCKCIPHER_TEST_FEATURE_OOP,
1732         },
1733         {
1734                 .test_descr = "AES-256-CTR HMAC-SHA1 Encryption Digest",
1735                 .test_data = &aes_test_data_3,
1736                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1737         },
1738         {
1739                 .test_descr = "AES-256-CTR HMAC-SHA1 Decryption Digest "
1740                         "Verify",
1741                 .test_data = &aes_test_data_3,
1742                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1743         },
1744         {
1745                 .test_descr = "AES-128-CBC HMAC-SHA1 Encryption Digest",
1746                 .test_data = &aes_test_data_4,
1747                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1748         },
1749         {
1750                 .test_descr = "AES-128-CBC HMAC-SHA1 Encryption Digest "
1751                         "(short buffers)",
1752                 .test_data = &aes_test_data_13,
1753                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1754         },
1755         {
1756                 .test_descr = "AES-128-CBC HMAC-SHA1 Encryption Digest "
1757                                 "Scatter Gather",
1758                 .test_data = &aes_test_data_4,
1759                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1760                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_SG |
1761                         BLOCKCIPHER_TEST_FEATURE_OOP,
1762         },
1763         {
1764                 .test_descr = "AES-128-CBC HMAC-SHA1 Decryption Digest "
1765                         "Verify",
1766                 .test_data = &aes_test_data_4,
1767                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1768         },
1769         {
1770                 .test_descr = "AES-128-CBC HMAC-SHA1 Decryption Digest "
1771                         "Verify Scatter Gather",
1772                 .test_data = &aes_test_data_4,
1773                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1774                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_SG,
1775         },
1776         {
1777                 .test_descr = "AES-128-CBC HMAC-SHA1 Decryption Digest "
1778                         "Verify (short buffers)",
1779                 .test_data = &aes_test_data_13,
1780                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1781         },
1782         {
1783                 .test_descr = "AES-128-CBC HMAC-SHA256 Encryption Digest",
1784                 .test_data = &aes_test_data_5,
1785                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1786         },
1787         {
1788                 .test_descr = "AES-128-CBC HMAC-SHA256 Encryption Digest "
1789                         "(short buffers)",
1790                 .test_data = &aes_test_data_12,
1791                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1792         },
1793         {
1794                 .test_descr = "AES-128-CBC HMAC-SHA256 Decryption Digest "
1795                         "Verify",
1796                 .test_data = &aes_test_data_5,
1797                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1798         },
1799         {
1800                 .test_descr = "AES-128-CBC HMAC-SHA256 Decryption Digest "
1801                         "Verify (short buffers)",
1802                 .test_data = &aes_test_data_12,
1803                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1804         },
1805         {
1806                 .test_descr = "AES-128-CBC HMAC-SHA512 Encryption Digest",
1807                 .test_data = &aes_test_data_6,
1808                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1809         },
1810         {
1811                 .test_descr = "AES-128-CBC HMAC-SHA512 Encryption Digest "
1812                         "Sessionless",
1813                 .test_data = &aes_test_data_6,
1814                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1815                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_SESSIONLESS,
1816         },
1817         {
1818                 .test_descr = "AES-128-CBC HMAC-SHA512 Encryption Digest "
1819                                 "Scatter Gather Sessionless",
1820                 .test_data = &aes_test_data_6,
1821                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1822                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_SESSIONLESS |
1823                         BLOCKCIPHER_TEST_FEATURE_SG |
1824                         BLOCKCIPHER_TEST_FEATURE_OOP,
1825         },
1826         {
1827                 .test_descr = "AES-128-CBC HMAC-SHA512 Decryption Digest "
1828                         "Verify",
1829                 .test_data = &aes_test_data_6,
1830                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1831         },
1832         {
1833                 .test_descr = "AES-128-CBC HMAC-SHA512 Decryption Digest "
1834                         "Verify Scatter Gather",
1835                 .test_data = &aes_test_data_6,
1836                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1837                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_SG |
1838                         BLOCKCIPHER_TEST_FEATURE_OOP,
1839         },
1840         {
1841                 .test_descr = "AES-128-CBC XCBC Encryption Digest",
1842                 .test_data = &aes_test_data_7,
1843                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1844         },
1845         {
1846                 .test_descr = "AES-128-CBC XCBC Decryption Digest Verify",
1847                 .test_data = &aes_test_data_7,
1848                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1849         },
1850         {
1851                 .test_descr = "AES-128-CBC HMAC-SHA1 Encryption Digest "
1852                         "OOP",
1853                 .test_data = &aes_test_data_4,
1854                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1855                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
1856         },
1857         {
1858                 .test_descr = "AES-128-CBC HMAC-SHA1 Encryption Digest "
1859                         "OOP Offset",
1860                 .test_data = &aes_test_data_14,
1861                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1862                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
1863         },
1864         {
1865                 .test_descr = "AES-128-CBC HMAC-SHA1 Decryption Digest "
1866                         "Verify OOP",
1867                 .test_data = &aes_test_data_4,
1868                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1869                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
1870         },
1871         {
1872                 .test_descr = "AES-128-CBC HMAC-SHA224 Encryption Digest",
1873                 .test_data = &aes_test_data_8,
1874                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1875         },
1876         {
1877                 .test_descr = "AES-128-CBC HMAC-SHA224 Decryption Digest "
1878                         "Verify",
1879                 .test_data = &aes_test_data_8,
1880                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1881         },
1882         {
1883                 .test_descr = "AES-128-CBC HMAC-SHA384 Encryption Digest",
1884                 .test_data = &aes_test_data_9,
1885                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1886         },
1887         {
1888                 .test_descr = "AES-128-CBC HMAC-SHA384 Decryption Digest "
1889                         "Verify",
1890                 .test_data = &aes_test_data_9,
1891                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1892         },
1893         {
1894                 .test_descr = "AES-128-CBC HMAC-SHA1 Encryption Digest "
1895                                 "Sessionless",
1896                 .test_data = &aes_test_data_4,
1897                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1898                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_SESSIONLESS,
1899         },
1900         {
1901                 .test_descr =
1902                                 "AES-128-CBC HMAC-SHA1 Decryption Digest "
1903                                 "Verify Sessionless",
1904                 .test_data = &aes_test_data_4,
1905                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1906                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_SESSIONLESS,
1907         },
1908         {
1909                 .test_descr = "NULL-CIPHER-NULL-AUTH encrypt & gen x8byte",
1910                 .test_data = &null_test_data_chain_x8_multiple,
1911                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1912         },
1913         {
1914                 .test_descr = "NULL-AUTH-NULL-CIPHER verify & decrypt x8byte",
1915                 .test_data = &null_test_data_chain_x8_multiple,
1916                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1917         },
1918         {
1919                 .test_descr = "NULL-CIPHER-NULL-AUTH encrypt & gen x8byte - OOP",
1920                 .test_data = &null_test_data_chain_x8_multiple,
1921                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1922                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
1923         },
1924         {
1925                 .test_descr = "NULL-AUTH-NULL-CIPHER verify & decrypt x8byte - OOP",
1926                 .test_data = &null_test_data_chain_x8_multiple,
1927                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1928                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
1929         },
1930         {
1931                 .test_descr = "NULL-CIPHER-NULL-AUTH encrypt & gen x4byte",
1932                 .test_data = &null_test_data_chain_x4_multiple,
1933                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1934         },
1935         {
1936                 .test_descr = "NULL-AUTH-NULL-CIPHER verify & decrypt x4byte",
1937                 .test_data = &null_test_data_chain_x4_multiple,
1938                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1939         },
1940         {
1941                 .test_descr = "NULL-CIPHER-NULL-AUTH encrypt & gen x4byte - OOP",
1942                 .test_data = &null_test_data_chain_x4_multiple,
1943                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1944                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
1945         },
1946         {
1947                 .test_descr = "NULL-AUTH-NULL-CIPHER verify & decrypt x4byte - OOP",
1948                 .test_data = &null_test_data_chain_x4_multiple,
1949                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1950                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
1951         },
1952         {
1953                 .test_descr = "NULL-CIPHER-NULL-AUTH encrypt & gen x1byte",
1954                 .test_data = &null_test_data_chain_x1_multiple,
1955                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1956         },
1957         {
1958                 .test_descr = "NULL-AUTH-NULL-CIPHER verify & decrypt x1byte",
1959                 .test_data = &null_test_data_chain_x1_multiple,
1960                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1961         },
1962         {
1963                 .test_descr = "NULL-CIPHER-NULL-AUTH encrypt & gen x1byte - OOP",
1964                 .test_data = &null_test_data_chain_x1_multiple,
1965                 .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
1966                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
1967         },
1968         {
1969                 .test_descr = "NULL-AUTH-NULL-CIPHER verify & decrypt x1byte - OOP",
1970                 .test_data = &null_test_data_chain_x1_multiple,
1971                 .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
1972                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
1973         },
1974 };
1975
1976 static const struct blockcipher_test_case aes_cipheronly_test_cases[] = {
1977         {
1978                 .test_descr = "AES-128-CBC Encryption",
1979                 .test_data = &aes_test_data_4,
1980                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
1981         },
1982         {
1983                 .test_descr = "AES-128-CBC Decryption",
1984                 .test_data = &aes_test_data_4,
1985                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
1986         },
1987         {
1988                 .test_descr = "AES-192-CBC Encryption",
1989                 .test_data = &aes_test_data_10,
1990                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
1991         },
1992         {
1993                 .test_descr = "AES-192-CBC Encryption Scater gather",
1994                 .test_data = &aes_test_data_10,
1995                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
1996                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_SG |
1997                         BLOCKCIPHER_TEST_FEATURE_OOP,
1998         },
1999         {
2000                 .test_descr = "AES-192-CBC Decryption",
2001                 .test_data = &aes_test_data_10,
2002                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2003         },
2004         {
2005                 .test_descr = "AES-192-CBC Decryption Scatter Gather",
2006                 .test_data = &aes_test_data_10,
2007                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2008                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_SG,
2009         },
2010         {
2011                 .test_descr = "AES-256-CBC Encryption",
2012                 .test_data = &aes_test_data_11,
2013                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2014         },
2015         {
2016                 .test_descr = "AES-256-CBC Decryption",
2017                 .test_data = &aes_test_data_11,
2018                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2019         },
2020         {
2021                 .test_descr = "AES-256-CBC OOP Encryption",
2022                 .test_data = &aes_test_data_11,
2023                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2024                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
2025         },
2026         {
2027                 .test_descr = "AES-256-CBC OOP Decryption",
2028                 .test_data = &aes_test_data_11,
2029                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2030                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
2031         },
2032         {
2033                 .test_descr = "AES-128-CTR Encryption",
2034                 .test_data = &aes_test_data_1,
2035                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2036         },
2037         {
2038                 .test_descr = "AES-128-CTR Decryption",
2039                 .test_data = &aes_test_data_1,
2040                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2041         },
2042         {
2043                 .test_descr = "AES-192-CTR Encryption",
2044                 .test_data = &aes_test_data_2,
2045                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2046         },
2047         {
2048                 .test_descr = "AES-192-CTR Decryption",
2049                 .test_data = &aes_test_data_2,
2050                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2051         },
2052         {
2053                 .test_descr = "AES-256-CTR Encryption",
2054                 .test_data = &aes_test_data_3,
2055                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2056         },
2057         {
2058                 .test_descr = "AES-256-CTR Decryption",
2059                 .test_data = &aes_test_data_3,
2060                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2061         },
2062         {
2063                 .test_descr = "AES-128-CTR Encryption (12-byte IV)",
2064                 .test_data = &aes_test_data_1_IV_12_bytes,
2065                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2066         },
2067         {
2068                 .test_descr = "AES-192-CTR Encryption (12-byte IV)",
2069                 .test_data = &aes_test_data_2_IV_12_bytes,
2070                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2071         },
2072         {
2073                 .test_descr = "AES-256-CTR Encryption (12-byte IV)",
2074                 .test_data = &aes_test_data_3_IV_12_bytes,
2075                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2076         },
2077         {
2078                 .test_descr = "AES-128-XTS Encryption (16-byte plaintext)",
2079                 .test_data = &aes_test_data_xts_key_32_pt_16,
2080                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2081         },
2082         {
2083                 .test_descr = "AES-128-XTS Decryption (16-byte plaintext)",
2084                 .test_data = &aes_test_data_xts_key_32_pt_16,
2085                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2086         },
2087         {
2088                 .test_descr = "AES-128-XTS Encryption (32-byte plaintext)",
2089                 .test_data = &aes_test_data_xts_key_32_pt_32,
2090                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2091         },
2092         {
2093                 .test_descr = "AES-128-XTS Decryption (32-byte plaintext)",
2094                 .test_data = &aes_test_data_xts_key_32_pt_32,
2095                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2096         },
2097         {
2098                 .test_descr = "AES-256-XTS Encryption (32-byte plaintext)",
2099                 .test_data = &aes_test_data_xts_key_64_pt_32,
2100                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2101         },
2102         {
2103                 .test_descr = "AES-256-XTS Decryption (32-byte plaintext)",
2104                 .test_data = &aes_test_data_xts_key_64_pt_32,
2105                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2106         },
2107         {
2108                 .test_descr = "AES-256-XTS Encryption (48-byte plaintext)",
2109                 .test_data = &aes_test_data_xts_key_64_pt_48,
2110                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2111         },
2112         {
2113                 .test_descr = "AES-256-XTS Decryption (48-byte plaintext)",
2114                 .test_data = &aes_test_data_xts_key_64_pt_48,
2115                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2116         },
2117         {
2118                 .test_descr = "cipher-only - NULL algo - x8 - encryption",
2119                 .test_data = &null_test_data_chain_x8_multiple,
2120                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2121         },
2122         {
2123                 .test_descr = "cipher-only - NULL algo - x8 - decryption",
2124                 .test_data = &null_test_data_chain_x8_multiple,
2125                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2126         },
2127         {
2128                 .test_descr = "cipher-only - NULL algo - x4 - encryption",
2129                 .test_data = &null_test_data_chain_x4_multiple,
2130                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2131         },
2132         {
2133                 .test_descr = "cipher-only - NULL algo - x4 - decryption",
2134                 .test_data = &null_test_data_chain_x4_multiple,
2135                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2136         },
2137         {
2138                 .test_descr = "cipher-only - NULL algo - x4 - encryption - OOP",
2139                 .test_data = &null_test_data_chain_x4_multiple,
2140                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2141                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
2142         },
2143         {
2144                 .test_descr = "cipher-only - NULL algo - x4 - decryption - OOP",
2145                 .test_data = &null_test_data_chain_x4_multiple,
2146                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2147                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
2148                 },
2149         {
2150                 .test_descr = "cipher-only - NULL algo - x1 - encryption",
2151                 .test_data = &null_test_data_chain_x1_multiple,
2152                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2153         },
2154         {
2155                 .test_descr = "cipher-only - NULL algo - x1 - decryption",
2156                 .test_data = &null_test_data_chain_x1_multiple,
2157                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2158         },
2159 };
2160
2161 static const struct blockcipher_test_case aes_docsis_test_cases[] = {
2162
2163         {
2164                 .test_descr = "AES-DOCSIS-BPI Full Block Encryption",
2165                 .test_data = &aes_test_data_docsis_1,
2166                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2167         },
2168         {
2169                 .test_descr = "AES-DOCSIS-BPI Runt Block Encryption",
2170                 .test_data = &aes_test_data_docsis_2,
2171                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2172         },
2173         {
2174                 .test_descr = "AES-DOCSIS-BPI Uneven Encryption",
2175                 .test_data = &aes_test_data_docsis_3,
2176                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2177         },
2178         {
2179                 .test_descr = "AES-DOCSIS-BPI Full Block Decryption",
2180                 .test_data = &aes_test_data_docsis_1,
2181                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2182         },
2183         {
2184                 .test_descr = "AES-DOCSIS-BPI Runt Block Decryption",
2185                 .test_data = &aes_test_data_docsis_2,
2186                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2187         },
2188         {
2189                 .test_descr = "AES-DOCSIS-BPI Uneven Decryption",
2190                 .test_data = &aes_test_data_docsis_3,
2191                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2192         },
2193         {
2194                 .test_descr = "AES-DOCSIS-BPI OOP Full Block Encryption",
2195                 .test_data = &aes_test_data_docsis_1,
2196                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2197                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
2198         },
2199         {
2200                 .test_descr = "AES-DOCSIS-BPI OOP Runt Block Encryption",
2201                 .test_data = &aes_test_data_docsis_2,
2202                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2203                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
2204         },
2205
2206         {
2207                 .test_descr = "AES-DOCSIS-BPI OOP Uneven Block Encryption",
2208                 .test_data = &aes_test_data_docsis_3,
2209                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2210                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
2211         },
2212         {
2213                 .test_descr = "AES-DOCSIS-BPI OOP Full Block Decryption",
2214                 .test_data = &aes_test_data_docsis_1,
2215                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2216                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
2217         },
2218         {
2219                 .test_descr = "AES-DOCSIS-BPI OOP Runt Block Decryption",
2220                 .test_data = &aes_test_data_docsis_2,
2221                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2222                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
2223         },
2224         {
2225                 .test_descr = "AES-DOCSIS-BPI OOP Uneven Block Decryption",
2226                 .test_data = &aes_test_data_docsis_3,
2227                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2228                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
2229         },
2230         /* AES 256 */
2231         {
2232                 .test_descr = "AES-256-DOCSIS-BPI Full Block Encryption",
2233                 .test_data = &aes_test_data_docsis_4,
2234                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2235         },
2236         {
2237                 .test_descr = "AES-256-DOCSIS-BPI Runt Block Encryption",
2238                 .test_data = &aes_test_data_docsis_5,
2239                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2240         },
2241         {
2242                 .test_descr = "AES-256-DOCSIS-BPI Uneven Encryption",
2243                 .test_data = &aes_test_data_docsis_6,
2244                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2245         },
2246         {
2247                 .test_descr = "AES-256-DOCSIS-BPI Full Block Decryption",
2248                 .test_data = &aes_test_data_docsis_4,
2249                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2250         },
2251         {
2252                 .test_descr = "AES-256-DOCSIS-BPI Runt Block Decryption",
2253                 .test_data = &aes_test_data_docsis_5,
2254                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2255         },
2256         {
2257                 .test_descr = "AES-256-DOCSIS-BPI Uneven Decryption",
2258                 .test_data = &aes_test_data_docsis_6,
2259                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2260         },
2261         {
2262                 .test_descr = "AES-256-DOCSIS-BPI OOP Full Block Encryption",
2263                 .test_data = &aes_test_data_docsis_4,
2264                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2265                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
2266         },
2267         {
2268                 .test_descr = "AES-256-DOCSIS-BPI OOP Runt Block Encryption",
2269                 .test_data = &aes_test_data_docsis_5,
2270                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2271                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
2272         },
2273         {
2274                 .test_descr = "AES-256-DOCSIS-BPI OOP Uneven Block Encryption",
2275                 .test_data = &aes_test_data_docsis_6,
2276                 .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
2277                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
2278         },
2279         {
2280                 .test_descr = "AES-256-DOCSIS-BPI OOP Full Block Decryption",
2281                 .test_data = &aes_test_data_docsis_4,
2282                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2283                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
2284         },
2285         {
2286                 .test_descr = "AES-256-DOCSIS-BPI OOP Runt Block Decryption",
2287                 .test_data = &aes_test_data_docsis_5,
2288                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2289                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
2290         },
2291         {
2292                 .test_descr = "AES-256-DOCSIS-BPI OOP Uneven Block Decryption",
2293                 .test_data = &aes_test_data_docsis_6,
2294                 .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
2295                 .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
2296         },
2297 };
2298 #endif /* TEST_CRYPTODEV_AES_TEST_VECTORS_H_ */