examples/fips_validation/fips_dev_self_test.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2019 Intel Corporation
   3  */
   4
   5 #include <rte_cryptodev.h>
   6 #include <rte_malloc.h>
   7
   8 #include "fips_dev_self_test.h"
   9
  10 #define IV_OFF (sizeof(struct rte_crypto_op) + sizeof(struct rte_crypto_sym_op))
  11
  12 #define FIPS_DEV_TEST_DATA_MAX_SIZE     8096
  13 #define AES_CCM_AAD_PAD_SIZE            18
  14
  15 struct fips_dev_self_test_vector {
  16         const char *name;
  17         enum rte_crypto_sym_xform_type operation_type;
  18
  19         struct {
  20                 uint8_t data[64];
  21                 uint16_t len;
  22         } digest;
  23
  24         struct {
  25                 uint8_t data[256];
  26                 uint16_t len;
  27         } key;
  28
  29         struct {
  30                 uint8_t data[16];
  31                 uint8_t len;
  32         } iv;
  33
  34         union {
  35                 struct {
  36                         enum rte_crypto_cipher_algorithm algo;
  37                 } cipher;
  38
  39                 struct {
  40                         enum rte_crypto_aead_algorithm algo;
  41                         struct {
  42                                 uint8_t data[FIPS_DEV_TEST_DATA_MAX_SIZE];
  43                                 uint16_t len;
  44                         } aad;
  45                 } aead;
  46
  47                 struct {
  48                         enum rte_crypto_auth_algorithm algo;
  49                 } auth;
  50         };
  51
  52         struct {
  53                 const uint8_t data[FIPS_DEV_TEST_DATA_MAX_SIZE];
  54                 uint16_t len;
  55         } input;
  56
  57         struct {
  58                 uint8_t data[FIPS_DEV_TEST_DATA_MAX_SIZE];
  59                 uint16_t len;
  60         } output;
  61 };
  62
  63 #define GET_MBUF_DATA(data, len, m)                     \
  64 do {                                                    \
  65         len = rte_pktmbuf_pkt_len(m);                   \
  66         data = rte_pktmbuf_mtod(m, uint8_t *);          \
  67 } while (0)
  68
  69
  70 /* <-- SHA-x HMAC --> */
  71 static struct fips_dev_self_test_vector
  72 SELF_TEST_SHA1_HMAC_test_vector = {
  73                 .name = "SELF_TEST_SHA1_HMAC_test_vector",
  74                 .operation_type = RTE_CRYPTO_SYM_XFORM_AUTH,
  75
  76                 .auth = {
  77                         .algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
  78                 },
  79                 .input = {
  80                         .data = {
  81                                 0xed, 0xb2, 0xba, 0x09, 0x99, 0x61, 0xd3, 0x8f,
  82                                 0xd0, 0xa0, 0xa6, 0xa2, 0x35, 0xd6, 0x12, 0x71,
  83                                 0xcb, 0x4d, 0x49, 0x3b, 0x64, 0xd9, 0xde, 0x13,
  84                                 0x5c, 0xbb, 0x1f, 0xe0, 0x86, 0xc4, 0xa4, 0xa7,
  85                                 0x67, 0xbe, 0x28, 0x0d, 0xa2, 0x07, 0x98, 0x17,
  86                                 0xb4, 0x7f, 0x6a, 0x35, 0xe1, 0xa4, 0x30, 0x7f,
  87                                 0x6e, 0xfc, 0x6d, 0x3e, 0x11, 0xb4, 0xa7, 0xae,
  88                                 0xa6, 0x86, 0xbd, 0x02, 0x23, 0xe0, 0x7b, 0xa9,
  89                                 0xce, 0x42, 0x6c, 0xd0, 0xae, 0xe7, 0xef, 0x28,
  90                                 0x3f, 0xa9, 0x8d, 0xe9, 0x6a, 0x1f, 0x8a, 0x17,
  91                                 0xb3, 0x08, 0xba, 0x04, 0xb5, 0xec, 0x96, 0x16,
  92                                 0xcb, 0x00, 0x8f, 0xca, 0x11, 0x4b, 0xa3, 0xf9,
  93                                 0x8b, 0x07, 0x2d, 0x5a, 0xa3, 0x4a, 0x01, 0x49,
  94                                 0xd9, 0xe5, 0xb8, 0xc6, 0xb6, 0x8c, 0x49, 0xc1,
  95                                 0x01, 0x38, 0xda, 0x95, 0x36, 0xca, 0xd5, 0xd2,
  96                                 0x34, 0xf1, 0x3d, 0x3f, 0x36, 0x4d, 0x43, 0x1f
  97                         },
  98                         .len = 128,
  99                 },
 100                 .key = {
 101                         .data = {
 102                                 0x8d, 0x8d, 0x15, 0xd8, 0xa9, 0x57, 0x9a, 0xdb,
 103                                 0x2d, 0x62
 104                         },
 105                         .len = 10,
 106                 },
 107                 .digest = {
 108                         .data = {
 109                                 0x0c, 0x66, 0x2e, 0x47, 0x93, 0x93, 0x8c, 0xc3,
 110                                 0x7f, 0x3d, 0x51, 0xd2, 0xb4, 0x05, 0x48, 0xec,
 111                                 0x55, 0x91, 0x4f, 0x0d
 112                         },
 113                         .len = 20,
 114                 },
 115 };
 116
 117 static struct fips_dev_self_test_vector
 118 SELF_TEST_SHA224_HMAC_test_vector = {
 119                 .name = "SELF_TEST_SHA224_HMAC_test_vector",
 120                 .operation_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 121                 .auth = {
 122                         .algo = RTE_CRYPTO_AUTH_SHA224_HMAC,
 123                 },
 124                 .input = {
 125                         .data = {
 126                                 0x41, 0x18, 0x43, 0xa2, 0x13, 0x87, 0x84, 0x6f,
 127                                 0x3b, 0x9e, 0xd5, 0xfc, 0x54, 0x5a, 0xca, 0xdf,
 128                                 0xa5, 0xb7, 0x03, 0x86, 0xf6, 0x2d, 0xa4, 0xd9,
 129                                 0xa2, 0x7b, 0x04, 0x1b, 0xee, 0xa3, 0xaa, 0x11,
 130                                 0x99, 0x36, 0x75, 0x67, 0xb4, 0xd1, 0x1a, 0x4f,
 131                                 0xb4, 0xe8, 0xd4, 0x6b, 0xc6, 0xc2, 0x56, 0xed,
 132                                 0x62, 0xc5, 0x05, 0xfd, 0x23, 0xf4, 0x64, 0x5b,
 133                                 0xd6, 0xb6, 0xcf, 0x45, 0xd1, 0xd9, 0x6d, 0x9b,
 134                                 0x86, 0xd6, 0x60, 0x41, 0x57, 0x57, 0x3e, 0xc5,
 135                                 0xac, 0xf6, 0xc5, 0x41, 0x43, 0x48, 0xca, 0x83,
 136                                 0xc8, 0x1a, 0x73, 0x6c, 0xa6, 0xfa, 0xa6, 0x96,
 137                                 0x1c, 0xfa, 0xc1, 0x39, 0x93, 0xb0, 0x8c, 0x50,
 138                                 0x2f, 0x81, 0x6c, 0xf7, 0xa4, 0x20, 0xd9, 0x18,
 139                                 0x4b, 0x51, 0x11, 0x46, 0x75, 0xf3, 0x0e, 0xe9,
 140                                 0xff, 0x3d, 0xb6, 0x9c, 0x26, 0x48, 0x53, 0xd3,
 141                                 0x9d, 0xcd, 0x42, 0xc1, 0xdd, 0x31, 0xef, 0x79
 142
 143                         },
 144                         .len = 128,
 145                 },
 146                 .key = {
 147                         .data = {
 148                                 0x37, 0x14, 0x70, 0x78, 0x39, 0xda, 0xf7, 0x91,
 149                                 0x22, 0xc7, 0x82, 0x41, 0x63, 0x51, 0x38, 0x5e,
 150                                 0x88, 0xa8, 0x1d, 0x31, 0xc9, 0xf6, 0x41, 0xd8,
 151                                 0xdc, 0xe5, 0x38, 0xe9, 0x0e, 0x63, 0xc9, 0x58,
 152                                 0x92, 0xa2, 0xea, 0x9b, 0x19, 0x62, 0xed, 0x0b,
 153                                 0xa3, 0x72, 0xf4, 0x8e, 0x94, 0x74, 0xaa, 0x73,
 154                                 0x0a, 0xe2
 155                         },
 156                         .len = 50,
 157                 },
 158                 .digest = {
 159                         .data = {
 160                                 0x33, 0xf1, 0x7a, 0xc8, 0xa5, 0xc6, 0xb5, 0x25,
 161                                 0xdb, 0x8b, 0x86, 0x44, 0xb6, 0xab
 162
 163                         },
 164                         .len = 14,
 165                 },
 166 };
 167
 168
 169 static struct fips_dev_self_test_vector
 170 SELF_TEST_SHA256_HMAC_test_vector = {
 171                 .name = "SELF_TEST_SHA256_HMAC_test_vector",
 172                 .operation_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 173                 .auth = {
 174                         .algo = RTE_CRYPTO_AUTH_SHA256_HMAC,
 175                 },
 176                 .input = {
 177                         .data = {
 178                                 0x1c, 0x43, 0x96, 0xf7, 0xb7, 0xf9, 0x22, 0x8e,
 179                                 0x83, 0x2a, 0x13, 0x69, 0x20, 0x02, 0xba, 0x2a,
 180                                 0xff, 0x43, 0x9d, 0xcb, 0x7f, 0xdd, 0xbf, 0xd4,
 181                                 0x56, 0xc0, 0x22, 0xd1, 0x33, 0xee, 0x89, 0x03,
 182                                 0xa2, 0xd4, 0x82, 0x56, 0x2f, 0xda, 0xa4, 0x93,
 183                                 0xce, 0x39, 0x16, 0xd7, 0x7a, 0x0c, 0x51, 0x44,
 184                                 0x1d, 0xab, 0x26, 0xf6, 0xb0, 0x34, 0x02, 0x38,
 185                                 0xa3, 0x6a, 0x71, 0xf8, 0x7f, 0xc3, 0xe1, 0x79,
 186                                 0xca, 0xbc, 0xa9, 0x48, 0x2b, 0x70, 0x49, 0x71,
 187                                 0xce, 0x69, 0xf3, 0xf2, 0x0a, 0xb6, 0x4b, 0x70,
 188                                 0x41, 0x3d, 0x6c, 0x29, 0x08, 0x53, 0x2b, 0x2a,
 189                                 0x88, 0x8a, 0x9f, 0xc2, 0x24, 0xca, 0xe1, 0x36,
 190                                 0x5d, 0xa4, 0x10, 0xb6, 0xf2, 0xe2, 0x98, 0x90,
 191                                 0x4b, 0x63, 0xb4, 0xa4, 0x17, 0x26, 0x32, 0x18,
 192                                 0x35, 0xa4, 0x77, 0x4d, 0xd0, 0x63, 0xc2, 0x11,
 193                                 0xcf, 0xc8, 0xb5, 0x16, 0x6c, 0x2d, 0x11, 0xa2
 194                         },
 195                         .len = 128,
 196                 },
 197                 .key = {
 198                         .data = {
 199                                 0x54, 0x48, 0x99, 0x8f, 0x9d, 0x8f, 0x98, 0x53,
 200                                 0x4a, 0xdd, 0xf0, 0xc8, 0xba, 0x63, 0x1c, 0x49,
 201                                 0x6b, 0xf8, 0xa8, 0x00, 0x6c, 0xbb, 0x46, 0xad,
 202                                 0x15, 0xfa, 0x1f, 0xa2, 0xf5, 0x53, 0x67, 0x12,
 203                                 0x0c, 0x19, 0x34, 0x8c, 0x3a, 0xfa, 0x90, 0xc3
 204                         },
 205                         .len = 40,
 206                 },
 207                 .digest = {
 208                         .data = {
 209                                 0x7e, 0x8c, 0xba, 0x9d, 0xd9, 0xf0, 0x6e, 0xbd,
 210                                 0xd7, 0xf9, 0x2e, 0x0f, 0x1a, 0x67, 0xc7, 0xf4,
 211                                 0xdf, 0x52, 0x69, 0x3c, 0x21, 0x2b, 0xdd, 0x84,
 212                                 0xf6, 0x73, 0x70, 0xb3, 0x51, 0x53, 0x3c, 0x6c
 213                         },
 214                         .len = 32,
 215                 },
 216 };
 217
 218 /* HMAC count=34 L=48 SHA384 GENERATE*/
 219 static struct fips_dev_self_test_vector
 220 SELF_TEST_SHA384_HMAC_test_vector = {
 221                 .name = "SELF_TEST_SHA384_HMAC_test_vector",
 222                 .operation_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 223                 .auth = {
 224                         .algo = RTE_CRYPTO_AUTH_SHA384_HMAC,
 225                 },
 226                 .input = {
 227                         .data = {
 228                                 0xf5, 0x10, 0x86, 0xfe, 0x78, 0x15, 0x0f, 0xe4,
 229                                 0x8b, 0xd1, 0x41, 0x5a, 0x47, 0x85, 0xac, 0xc0,
 230                                 0x5a, 0xb8, 0x0e, 0xf0, 0x0b, 0x29, 0x75, 0xce,
 231                                 0x78, 0x07, 0xa4, 0x21, 0x22, 0x64, 0xb8, 0xa1,
 232                                 0xac, 0xe8, 0x0b, 0x50, 0xe0, 0xc2, 0x59, 0x0e,
 233                                 0xf3, 0xe4, 0x21, 0x68, 0x0a, 0x70, 0x4e, 0xb2,
 234                                 0xfc, 0x6d, 0x17, 0x55, 0x5a, 0xbf, 0x24, 0x69,
 235                                 0xad, 0x56, 0xf2, 0x87, 0xfe, 0xa5, 0x78, 0xd8,
 236                                 0x9c, 0x56, 0x0b, 0x72, 0x19, 0x3c, 0x7f, 0xe5,
 237                                 0x96, 0x89, 0x8f, 0x10, 0x40, 0x41, 0x7e, 0x3a,
 238                                 0x1b, 0xee, 0xff, 0x5e, 0xff, 0x96, 0x53, 0xc5,
 239                                 0xe0, 0xea, 0xb1, 0xda, 0x52, 0xc0, 0xea, 0x3b,
 240                                 0x4b, 0xc3, 0x4d, 0x0c, 0x2b, 0x69, 0xc8, 0x90,
 241                                 0xfb, 0x26, 0x51, 0xfa, 0xf2, 0xe0, 0x84, 0x80,
 242                                 0x3e, 0xa2, 0x8e, 0xb2, 0x01, 0x94, 0x49, 0x0a,
 243                                 0x99, 0x2b, 0xa8, 0xc4, 0x24, 0x9d, 0x56, 0xef
 244                         },
 245                         .len = 128,
 246                 },
 247                 .key = {
 248                         .data = {
 249                                 0x91, 0x7a, 0x69, 0x8c, 0x82, 0xf4, 0x4f, 0x19,
 250                                 0x57, 0x3b, 0x64, 0x5c, 0x48, 0x79, 0xb8, 0x73,
 251                                 0x0b, 0x58, 0xdf, 0xf4, 0xed, 0xc6, 0xa0, 0xd3,
 252                                 0x21, 0xf5, 0xf1, 0x86, 0x58, 0xa5, 0x24, 0x66,
 253                                 0x92, 0xa5, 0x5b, 0x59, 0x33, 0x97, 0x41, 0xae,
 254                                 0x59, 0xf5, 0xfc, 0x48, 0x6d, 0x51, 0x5d, 0xff,
 255                                 0xf8, 0xe1
 256                         },
 257                         .len = 50,
 258                 },
 259                 .digest = {
 260                         .data = {
 261                                 0x77, 0xbf, 0x56, 0x15, 0xec, 0x52, 0xf7, 0x06,
 262                                 0xca, 0x74, 0x64, 0x01, 0xe9, 0xfd, 0xe4, 0x3f,
 263                                 0x15, 0x60, 0x52, 0x37, 0xe5, 0x50, 0xb9, 0x3a,
 264                                 0x84, 0x72, 0xfd, 0x14, 0x4f, 0xc3, 0x9e, 0x5e,
 265                                 0xca, 0x0f, 0xe8, 0x90, 0x83, 0x88, 0x28, 0xa0
 266                         },
 267                         .len = 40,
 268                 },
 269 };
 270
 271 /* HMAC count=28 L=64 SHA512 GENERATE*/
 272 static struct fips_dev_self_test_vector
 273 SELF_TEST_SHA512_HMAC_test_vector = {
 274                 .name = "SELF_TEST_SHA512_HMAC_test_vector",
 275                 .operation_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 276                 .auth = {
 277                         .algo = RTE_CRYPTO_AUTH_SHA512_HMAC,
 278                 },
 279                 .input = {
 280                         .data = {
 281                                 0x0a, 0x33, 0x1c, 0xe2, 0x00, 0x89, 0xb2, 0x9e,
 282                                 0x94, 0xb2, 0xc5, 0xf5, 0x18, 0xc8, 0xdb, 0xea,
 283                                 0xd4, 0x04, 0x17, 0xa2, 0xa8, 0xd5, 0x00, 0x18,
 284                                 0xf3, 0x2f, 0x85, 0x12, 0xb3, 0x26, 0x3d, 0x54,
 285                                 0xed, 0xbb, 0xf3, 0x13, 0x4f, 0xf6, 0x61, 0xac,
 286                                 0x14, 0x35, 0x3c, 0x96, 0x28, 0xc3, 0x71, 0x95,
 287                                 0x8c, 0xac, 0xaf, 0x31, 0xfd, 0xd0, 0x25, 0x67,
 288                                 0xd0, 0x37, 0x8d, 0x9e, 0x21, 0xa4, 0x69, 0xdd,
 289                                 0x2c, 0x6d, 0x8c, 0x3a, 0xfb, 0x89, 0xdd, 0x96,
 290                                 0x42, 0xeb, 0x58, 0x87, 0x87, 0x0e, 0x55, 0x96,
 291                                 0x85, 0xd2, 0x0d, 0xab, 0xd3, 0x86, 0x5a, 0xc5,
 292                                 0xc1, 0x46, 0xbe, 0xee, 0x83, 0x87, 0xa7, 0x6f,
 293                                 0x91, 0xf0, 0xf1, 0x40, 0x4d, 0x6c, 0xad, 0xc2,
 294                                 0xe6, 0x7d, 0x21, 0xb0, 0x7d, 0xd3, 0x0f, 0x53,
 295                                 0x87, 0x1d, 0x3b, 0xf6, 0x73, 0x1f, 0x27, 0x9a,
 296                                 0x8c, 0x04, 0x21, 0xeb, 0x20, 0xf6, 0x7f, 0x72
 297                         },
 298                         .len = 128,
 299                 },
 300                 .key = {
 301                         .data = {
 302                                 0x39, 0xb8, 0x77, 0xb8, 0xe8, 0x2e, 0xcb, 0xd9,
 303                                 0x74, 0x03, 0x25, 0x82, 0x8f, 0xaf, 0x67, 0x21,
 304                                 0xc1, 0x29, 0x04, 0x6e, 0xb0, 0x13, 0x61, 0x44,
 305                                 0xa0, 0x31, 0x82, 0xb1, 0x36, 0x20, 0xe2, 0x49,
 306                                 0x81, 0x45, 0xa2, 0xbf, 0x3b, 0x03, 0xe6, 0xb6,
 307                                 0x4b, 0x31, 0x7d, 0xd4, 0x8f, 0xcb, 0xc0, 0x18,
 308                                 0xd9, 0xe7, 0xbc, 0x6e, 0x37, 0xeb, 0x93, 0x81,
 309                                 0x78, 0xfe, 0x1f, 0xd1, 0xeb, 0xbc, 0xd9, 0x05,
 310                                 0x6a, 0x2e, 0xf9, 0x82, 0x97, 0xf9, 0xdf, 0x3c,
 311                                 0x66, 0xd5, 0xb2, 0xcc, 0xdc, 0x41, 0x47, 0xc4,
 312                                 0x16, 0x76, 0x44, 0x3f, 0x8c, 0x99, 0x85, 0xbc,
 313                                 0x97, 0x34, 0xbe, 0x2c, 0x31, 0xe7, 0x62, 0x49,
 314                                 0xfc, 0x5b, 0xc4, 0x2a
 315                         },
 316                         .len = 100,
 317                 },
 318                 .digest = {
 319                         .data = {
 320                                 0x97, 0x16, 0x8f, 0x55, 0x13, 0xc2, 0xe9, 0xbc,
 321                                 0x4b, 0xc5, 0x25, 0xce, 0x27, 0x03, 0x74, 0x0b,
 322                                 0xce, 0x1a, 0x06, 0xec, 0xfe, 0x99, 0xa5, 0x70,
 323                                 0xac, 0x66, 0xc8, 0x3e, 0xde, 0x96, 0x67, 0xcc,
 324                                 0x07, 0xed, 0xf6, 0x64, 0x61, 0x7c, 0xe5, 0x3c
 325                         },
 326                         .len = 40,
 327                 },
 328 };
 329
 330 /* <-- AES CMAC --> */
 331 static struct fips_dev_self_test_vector
 332 SELF_TEST_AES_CMAC_test_vector = {
 333                 .name = "SELF_TEST_AES_CMAC_test_vector",
 334                 .operation_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 335                 .auth = {
 336                         .algo = RTE_CRYPTO_AUTH_AES_CMAC,
 337                 },
 338                 .input = {
 339                         .data = {
 340                                 0x57, 0x88, 0xf6, 0x1e, 0x02, 0x30, 0x47, 0x91,
 341                                 0xb5, 0x2f, 0x40, 0x05, 0x7a, 0xbb, 0x4e, 0x04,
 342                                 0x46, 0x40, 0x3e, 0xf3, 0x74, 0x02, 0x53, 0xdf,
 343                                 0x72, 0x05, 0x96, 0x79, 0xbb, 0x2a, 0x6e, 0x5e,
 344                                 0x05, 0x9a, 0x70, 0x9c, 0xbb
 345                         },
 346                         .len = 37,
 347                 },
 348                 .key = {
 349                         .data = {
 350                                 0x18, 0x42, 0x15, 0x14, 0x5d, 0xa4, 0x9d, 0xb4,
 351                                 0x17, 0xe8, 0xbd, 0xd5, 0x73, 0xd6, 0x28, 0x2d
 352                         },
 353                         .len = 16,
 354                 },
 355                 .digest = {
 356                         .data = {
 357                                 0x8d, 0xa8, 0xcc, 0xa9, 0xb3, 0x6f, 0x68, 0x57,
 358                                 0x1c, 0x6c, 0x0e, 0x40, 0xa3, 0xf4, 0x10
 359                         },
 360                         .len = 15,
 361                 },
 362 };
 363
 364 /* <-- AES CCM --> */
 365 static struct fips_dev_self_test_vector
 366 SELF_TEST_AES128_CCM_test_vector = {
 367                 .name = "SELF_TEST_AES128_CCM_test_vector",
 368                 .operation_type = RTE_CRYPTO_SYM_XFORM_AEAD,
 369                 .iv = {
 370                         .data = {
 371                                 0x00, 0x50, 0x30, 0xF1, 0x84, 0x44, 0x08, 0xB5,
 372                                 0x03, 0x97, 0x76, 0xE7, 0x0C
 373                         },
 374                         .len = 13,
 375                 },
 376                 .aead = {
 377                         .algo = RTE_CRYPTO_AEAD_AES_CCM,
 378                         .aad = {
 379                                 .data = {
 380                                         /* 18 bytes padding for AAD */
 381                                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 382                                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 383                                         0x00, 0x00,
 384                                         0x08, 0x40, 0x0F, 0xD2, 0xE1, 0x28, 0xA5, 0x7C,
 385                                         0x50, 0x30, 0xF1, 0x84, 0x44, 0x08, 0xAB, 0xAE,
 386                                         0xA5, 0xB8, 0xFC, 0xBA, 0x00, 0x00
 387                                 },
 388                                 .len = 22,
 389                         },
 390                 },
 391                 .input = {
 392                         .data = {
 393                                 0xF8, 0xBA, 0x1A, 0x55, 0xD0, 0x2F, 0x85, 0xAE,
 394                                 0x96, 0x7B, 0xB6, 0x2F, 0xB6, 0xCD, 0xA8, 0xEB,
 395                                 0x7E, 0x78, 0xA0, 0x50
 396                         },
 397                         .len = 20,
 398                 },
 399                 .key = {
 400                         .data = {
 401                                 0xC9, 0x7C, 0x1F, 0x67, 0xCE, 0x37, 0x11, 0x85,
 402                                 0x51, 0x4A, 0x8A, 0x19, 0xF2, 0xBD, 0xD5, 0x2F
 403                         },
 404                         .len = 16,
 405                 },
 406                 .output = {
 407                         .data = {
 408                                 0xF3, 0xD0, 0xA2, 0xFE, 0x9A, 0x3D, 0xBF, 0x23,
 409                                 0x42, 0xA6, 0x43, 0xE4, 0x32, 0x46, 0xE8, 0x0C,
 410                                 0x3C, 0x04, 0xD0, 0x19
 411                         },
 412                         .len = 20,
 413                 },
 414                 .digest = {
 415                         .data = {
 416                                 0x78, 0x45, 0xCE, 0x0B, 0x16, 0xF9, 0x76, 0x23
 417                         },
 418                         .len = 8,
 419                 },
 420 };
 421
 422 /* <-- AES CBC --> */
 423 static struct fips_dev_self_test_vector
 424 SELF_TEST_AES128_CBC_test_vector = {
 425                 .name = "SELF_TEST_AES128_CBC_test_vector",
 426                 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 427
 428                 .iv = {
 429                         .data = {
 430                                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 431                                 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
 432                         },
 433                         .len = 16,
 434                 },
 435                 .cipher = {
 436                         .algo = RTE_CRYPTO_CIPHER_AES_CBC,
 437                 },
 438                 .input = {
 439                         .data = {
 440                                 0x57, 0x68, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6C,
 441                                 0x6F, 0x75, 0x73, 0x79, 0x20, 0x65, 0x61, 0x72,
 442                                 0x74, 0x68, 0x21, 0x20, 0x48, 0x65, 0x20, 0x77,
 443                                 0x6F, 0x6E, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20,
 444                         },
 445                         .len = 32,
 446                 },
 447                 .key = {
 448                         .data = {
 449                                 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
 450                                 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
 451                         },
 452                         .len = 16,
 453                 },
 454                 .output = {
 455                         .data = {
 456                                 0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
 457                                 0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
 458                                 0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
 459                                 0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
 460                         },
 461                         .len = 32,
 462                 },
 463 };
 464
 465 static struct fips_dev_self_test_vector
 466 SELF_TEST_AES192_CBC_test_vector = {
 467                 .name = "SELF_TEST_AES192_CBC_test_vector",
 468                 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 469
 470                 .iv = {
 471                         .data = {
 472                                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 473                                 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
 474                         },
 475                         .len = 16,
 476                 },
 477                 .cipher = {
 478                         .algo = RTE_CRYPTO_CIPHER_AES_CBC,
 479                 },
 480                 .input = {
 481                         .data = {
 482                                 0x57, 0x68, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6C,
 483                                 0x6F, 0x75, 0x73, 0x79, 0x20, 0x65, 0x61, 0x72,
 484                                 0x74, 0x68, 0x21, 0x20, 0x48, 0x65, 0x20, 0x77,
 485                                 0x6F, 0x6E, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20,
 486                         },
 487                         .len = 32,
 488                 },
 489                 .key = {
 490                         .data = {
 491                                 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
 492                                 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
 493                                 0xD4, 0xC3, 0xA3, 0xAA, 0x33, 0x62, 0x61, 0xE0
 494                         },
 495                         .len = 24,
 496                 },
 497                 .output = {
 498                         .data = {
 499                                 0x45, 0xEE, 0x9A, 0xEA, 0x3C, 0x03, 0xFC, 0x4C,
 500                                 0x84, 0x36, 0xB0, 0xDA, 0xB0, 0xDC, 0xF3, 0x5B,
 501                                 0x75, 0xA7, 0xBE, 0x0E, 0xC0, 0x8D, 0x6C, 0xF8,
 502                                 0xC1, 0x0F, 0xD0, 0x35, 0x1D, 0x82, 0xAE, 0x7C,
 503                         },
 504                         .len = 32,
 505                 },
 506 };
 507
 508 /* AES-256 CBC ENCRYPT*/
 509 static struct fips_dev_self_test_vector
 510 SELF_TEST_AES256_CBC_test_vector = {
 511                 .name = "SELF_TEST_AES256_CBC_test_vector",
 512                 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 513
 514                 .iv = {
 515                         .data = {
 516                                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 517                                 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
 518                         },
 519                         .len = 16,
 520                 },
 521                 .cipher = {
 522                         .algo = RTE_CRYPTO_CIPHER_AES_CBC,
 523                 },
 524                 .input = {
 525                         .data = {
 526                                 0x57, 0x68, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6C,
 527                                 0x6F, 0x75, 0x73, 0x79, 0x20, 0x65, 0x61, 0x72,
 528                                 0x74, 0x68, 0x21, 0x20, 0x48, 0x65, 0x20, 0x77,
 529                                 0x6F, 0x6E, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20,
 530                         },
 531                         .len = 32,
 532                 },
 533                 .key = {
 534                         .data = {
 535                                 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
 536                                 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
 537                                 0xD4, 0xC3, 0xA3, 0xAA, 0x33, 0x62, 0x61, 0xE0,
 538                                 0x37, 0x07, 0xB8, 0x23, 0xA2, 0xA3, 0xB5, 0x8D
 539                         },
 540                         .len = 32,
 541                 },
 542                 .output = {
 543                         .data = {
 544                                 0xF3, 0xDD, 0xF0, 0x0B, 0xFF, 0xA2, 0x6A, 0x04,
 545                                 0xBE, 0xDA, 0x52, 0xA6, 0xFE, 0x6B, 0xA6, 0xA7,
 546                                 0x48, 0x1D, 0x7D, 0x98, 0x65, 0xDB, 0xEF, 0x06,
 547                                 0x26, 0xB5, 0x8E, 0xEB, 0x05, 0x0E, 0x77, 0x98,
 548                         },
 549                         .len = 32,
 550                 },
 551 };
 552
 553 /* DES-128 CBC ENCRYPT*/
 554 static struct fips_dev_self_test_vector
 555 SELF_TEST_3DES_2KEY_CBC_test_vector = {
 556                 .name = "SELF_TEST_3DES_2KEY_CBC_test_vector",
 557                 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 558                 .iv = {
 559                         .data = {
 560                                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
 561                         },
 562                         .len = 8,
 563                 },
 564                 .cipher = {
 565                         .algo = RTE_CRYPTO_CIPHER_3DES_CBC,
 566                 },
 567                 .input = {
 568                         .data = {
 569                                 0x57, 0x68, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6C,
 570                                 0x6F, 0x75, 0x73, 0x79, 0x20, 0x65, 0x61, 0x72,
 571                                 0x74, 0x68, 0x21, 0x20, 0x48, 0x65, 0x20, 0x77,
 572                                 0x6F, 0x6E, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20,
 573                         },
 574                         .len = 32,
 575                 },
 576                 .key = {
 577                         .data = {
 578                                 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
 579                                 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
 580                                 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2
 581                         },
 582                         .len = 24,
 583                 },
 584                 .output = {
 585                         .data = {
 586                                 0x28, 0x2a, 0xff, 0x15, 0x5c, 0xdf, 0xd9, 0x6b,
 587                                 0x54, 0xbc, 0x7b, 0xfb, 0xc5, 0x64, 0x4d, 0xdd,
 588                                 0x3e, 0xf2, 0x9e, 0xb7, 0x53, 0x65, 0x37, 0x05,
 589                                 0xe0, 0xdf, 0xae, 0xf7, 0xc9, 0x27, 0xe4, 0xec,
 590                         },
 591                         .len = 32,
 592                 },
 593 };
 594
 595 static struct fips_dev_self_test_vector
 596 SELF_TEST_3DES_3KEY_CBC_test_vector = {
 597                 .name = "SELF_TEST_3DES_3KEY_CBC_test_vector",
 598                 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 599
 600                 .iv = {
 601                         .data = {
 602                                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
 603                         },
 604                         .len = 8,
 605                 },
 606                 .cipher = {
 607                         .algo = RTE_CRYPTO_CIPHER_3DES_CBC,
 608                 },
 609                 .input = {
 610                         .data = {
 611                                 0x57, 0x68, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6C,
 612                                 0x6F, 0x75, 0x73, 0x79, 0x20, 0x65, 0x61, 0x72,
 613                                 0x74, 0x68, 0x21, 0x20, 0x48, 0x65, 0x20, 0x77,
 614                                 0x6F, 0x6E, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20,
 615                         },
 616                         .len = 32,
 617                 },
 618                 .key = {
 619                         .data = {
 620                                 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
 621                                 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
 622                                 0xD4, 0xC3, 0xA3, 0xAA, 0x33, 0x62, 0x61, 0xE0
 623                         },
 624                         .len = 24,
 625                 },
 626                 .output = {
 627                         .data = {
 628                                 0xd0, 0xc9, 0xdc, 0x51, 0x29, 0x97, 0x03, 0x64,
 629                                 0xcd, 0x22, 0xba, 0x3d, 0x2b, 0xbc, 0x21, 0x37,
 630                                 0x7b, 0x1e, 0x29, 0x23, 0xeb, 0x51, 0x6e, 0xac,
 631                                 0xbe, 0x5b, 0xd3, 0x67, 0xe0, 0x3f, 0xc3, 0xb5,
 632                         },
 633                         .len = 32,
 634                 },
 635 };
 636
 637 /* <-- AES GCM --> */
 638 static struct fips_dev_self_test_vector
 639 SELF_TEST_AES128_GCM_encrypt_test_vector = {
 640                 .name = "SELF_TEST_AES128_GCM_encrypt_test_vector",
 641                 .operation_type = RTE_CRYPTO_SYM_XFORM_AEAD,
 642
 643                 .iv = {
 644                         .data = {
 645                                 0x5a, 0xdb, 0x96, 0x09, 0xdb, 0xae, 0xb5, 0x8c,
 646                                 0xbd, 0x6e, 0x72, 0x75
 647                         },
 648                         .len = 12,
 649                 },
 650                 .aead = {
 651                         .algo = RTE_CRYPTO_AEAD_AES_GCM,
 652                         .aad = {
 653                                 .data = {
 654                                         0x88, 0x31, 0x9d, 0x6e, 0x1d, 0x3f, 0xfa, 0x5f,
 655                                         0x98, 0x71, 0x99, 0x16, 0x6c, 0x8a, 0x9b, 0x56,
 656                                         0xc2, 0xae, 0xba, 0x5a
 657                                 },
 658                                 .len = 20,
 659                         },
 660                 },
 661                 .input = {
 662                         .data = {
 663                                 0x7c, 0x0e, 0x88, 0xc8, 0x88, 0x99, 0xa7, 0x79,
 664                                 0x22, 0x84, 0x65, 0x07, 0x47, 0x97, 0xcd, 0x4c,
 665                                 0x2e, 0x14, 0x98, 0xd2, 0x59, 0xb5, 0x43, 0x90,
 666                                 0xb8, 0x5e, 0x3e, 0xef, 0x1c, 0x02, 0xdf, 0x60,
 667                                 0xe7, 0x43, 0xf1, 0xb8, 0x40, 0x38, 0x2c, 0x4b,
 668                                 0xcc, 0xaf, 0x3b, 0xaf, 0xb4, 0xca, 0x84, 0x29,
 669                                 0xbe, 0xa0, 0x63
 670                         },
 671                         .len = 51,
 672                 },
 673                 .key = {
 674                         .data = {
 675                                 0xfe, 0x47, 0xfc, 0xce, 0x5f, 0xc3, 0x26, 0x65,
 676                                 0xd2, 0xae, 0x39, 0x9e, 0x4e, 0xec, 0x72, 0xba
 677                         },
 678                         .len = 16,
 679                 },
 680                 .output = {
 681                         .data = {
 682                                 0x98, 0xf4, 0x82, 0x6f, 0x05, 0xa2, 0x65, 0xe6,
 683                                 0xdd, 0x2b, 0xe8, 0x2d, 0xb2, 0x41, 0xc0, 0xfb,
 684                                 0xbb, 0xf9, 0xff, 0xb1, 0xc1, 0x73, 0xaa, 0x83,
 685                                 0x96, 0x4b, 0x7c, 0xf5, 0x39, 0x30, 0x43, 0x73,
 686                                 0x63, 0x65, 0x25, 0x3d, 0xdb, 0xc5, 0xdb, 0x87,
 687                                 0x78, 0x37, 0x14, 0x95, 0xda, 0x76, 0xd2, 0x69,
 688                                 0xe5, 0xdb, 0x3e
 689                         },
 690                         .len = 51,
 691                 },
 692                 .digest = {
 693                         .data = {
 694                                 0x29, 0x1e, 0xf1, 0x98, 0x2e, 0x4d, 0xef, 0xed,
 695                                 0xaa, 0x22, 0x49, 0xf8, 0x98, 0x55, 0x6b, 0x47
 696                         },
 697                         .len = 16,
 698                 },
 699 };
 700
 701 static struct fips_dev_self_test_vector
 702 SELF_TEST_AES192_GCM_encrypt_test_vector = {
 703                 .operation_type = RTE_CRYPTO_SYM_XFORM_AEAD,
 704                 .name = "SELF_TEST_AES192_GCM_encrypt_test_vector",
 705                 .iv = {
 706                         .data = {
 707                                 0x0b, 0xd4, 0x4f, 0xf4, 0xd2, 0x0c, 0x15, 0xd0,
 708                                 0x4f, 0xc6, 0x1e, 0xe7
 709                         },
 710                         .len = 12,
 711                 },
 712                 .aead = {
 713                         .algo = RTE_CRYPTO_AEAD_AES_GCM,
 714                         .aad = {
 715                                 .data = {
 716                                         0x9e, 0xa4, 0x2c, 0x50, 0xa7, 0xfd, 0xb8, 0x5e,
 717                                         0x14, 0x1a, 0xa0, 0x84, 0xb4, 0x6b, 0xde, 0x12
 718                                 },
 719                                 .len = 16,
 720                         },
 721                 },
 722                 .input = {
 723                         .data = {
 724                                 0x56, 0x7c, 0xcb, 0x3f, 0xa0, 0xdb, 0x89, 0x70,
 725                                 0x8a, 0xf3, 0xff, 0x2b, 0xb0, 0x29, 0xdd, 0xec,
 726                                 0x52, 0xc6, 0x69, 0x47, 0x58, 0x5d, 0x29, 0x1a,
 727                                 0x28, 0x56, 0x4b, 0xf5, 0x6d, 0xb7, 0x06, 0xf7
 728                         },
 729                         .len = 32,
 730                 },
 731                 .key = {
 732                         .data = {
 733                                 0x0d, 0x4a, 0x90, 0x0d, 0x1b, 0x0b, 0xb5, 0xb7,
 734                                 0xbe, 0x24, 0x38, 0xc2, 0xba, 0x48, 0xfc, 0x45,
 735                                 0x13, 0x4c, 0xc1, 0x98, 0x10, 0x8c, 0xf8, 0x85
 736                         },
 737                         .len = 24,
 738                 },
 739                 .output = {
 740                         .data = {
 741                                 0x2f, 0x8a, 0x42, 0xcd, 0x18, 0x3b, 0x03, 0x14,
 742                                 0xfd, 0x20, 0xa3, 0xd9, 0x7d, 0x9e, 0x0c, 0x52,
 743                                 0x17, 0xb0, 0xf0, 0x88, 0xd2, 0xca, 0x87, 0xa8,
 744                                 0x29, 0x0d, 0x4b, 0xae, 0x69, 0xad, 0x83, 0xf5
 745                         },
 746                         .len = 32,
 747                 },
 748                 .digest = {
 749                         .data = {
 750                                 0xde, 0x41, 0x45, 0x92, 0xd7, 0x7f, 0x2f, 0x0b,
 751                                 0x50, 0xdf, 0x4a, 0xec, 0x71, 0x4f, 0xad, 0x43
 752                         },
 753                         .len = 16,
 754                 },
 755 };
 756
 757 static struct fips_dev_self_test_vector
 758 SELF_TEST_AES256_GCM_encrypt_test_vector = {
 759                 .operation_type = RTE_CRYPTO_SYM_XFORM_AEAD,
 760                 .name = "SELF_TEST_AES256_GCM_encrypt_test_vector",
 761                 .iv = {
 762                         .data = {
 763                                 0x5c, 0x1b, 0x21, 0xc8, 0x99, 0x8e, 0xd6, 0x29,
 764                                 0x90, 0x06, 0xd3, 0xf9
 765                         },
 766                         .len = 12,
 767                 },
 768                 .aead = {
 769                         .algo = RTE_CRYPTO_AEAD_AES_GCM,
 770                         .aad = {
 771                                 .data = {
 772                                         0x22, 0xed, 0x23, 0x59, 0x46, 0x23, 0x5a, 0x85,
 773                                         0xa4, 0x5b, 0xc5, 0xfa, 0xd7, 0x14, 0x0b, 0xfa
 774                                 },
 775                                 .len = 16,
 776                         },
 777                 },
 778                 .input = {
 779                         .data = {
 780                                 0xad, 0x42, 0x60, 0xe3, 0xcd, 0xc7, 0x6b, 0xcc,
 781                                 0x10, 0xc7, 0xb2, 0xc0, 0x6b, 0x80, 0xb3, 0xbe,
 782                                 0x94, 0x82, 0x58, 0xe5, 0xef, 0x20, 0xc5, 0x08,
 783                                 0xa8, 0x1f, 0x51, 0xe9, 0x6a, 0x51, 0x83, 0x88
 784                         },
 785                         .len = 32,
 786                 },
 787                 .key = {
 788                         .data = {
 789                                 0x37, 0xcc, 0xdb, 0xa1, 0xd9, 0x29, 0xd6, 0x43,
 790                                 0x6c, 0x16, 0xbb, 0xa5, 0xb5, 0xff, 0x34, 0xde,
 791                                 0xec, 0x88, 0xed, 0x7d, 0xf3, 0xd1, 0x5d, 0x0f,
 792                                 0x4d, 0xdf, 0x80, 0xc0, 0xc7, 0x31, 0xee, 0x1f
 793                         },
 794                         .len = 32,
 795                 },
 796                 .output = {
 797                         .data = {
 798                                 0x3b, 0x33, 0x5f, 0x8b, 0x08, 0xd3, 0x3c, 0xcd,
 799                                 0xca, 0xd2, 0x28, 0xa7, 0x47, 0x00, 0xf1, 0x00,
 800                                 0x75, 0x42, 0xa4, 0xd1, 0xe7, 0xfc, 0x1e, 0xbe,
 801                                 0x3f, 0x44, 0x7f, 0xe7, 0x1a, 0xf2, 0x98, 0x16
 802                         },
 803                         .len = 32,
 804                 },
 805                 .digest = {
 806                         .data = {
 807                                 0x1f, 0xbf, 0x49, 0xcc, 0x46, 0xf4, 0x58, 0xbf,
 808                                 0x6e, 0x88, 0xf6, 0x37, 0x09, 0x75, 0xe6, 0xd4
 809                         },
 810                         .len = 16,
 811                 },
 812 };
 813
 814
 815 /* <-- AES CTR --> */
 816 static struct fips_dev_self_test_vector
 817 SELF_TEST_AES128_CTR_test_vector = {
 818                 .name = "SELF_TEST_AES128_CTR_test_vector",
 819                 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 820
 821                 .iv = {
 822                         .data = {
 823                                 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
 824                                 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
 825                         },
 826                         .len = 16,
 827                 },
 828                 .cipher = {
 829                         .algo = RTE_CRYPTO_CIPHER_AES_CTR,
 830                 },
 831                 .input = {
 832                         .data = {
 833                                 0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,
 834                                 0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A,
 835                                 0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C,
 836                                 0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51,
 837                         },
 838                         .len = 32,
 839                 },
 840                 .key = {
 841                         .data = {
 842                                 0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
 843                                 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
 844                         },
 845                         .len = 16,
 846                 },
 847                 .output = {
 848                         .data = {
 849                                 0x87, 0x4D, 0x61, 0x91, 0xB6, 0x20, 0xE3, 0x26,
 850                                 0x1B, 0xEF, 0x68, 0x64, 0x99, 0x0D, 0xB6, 0xCE,
 851                                 0x98, 0x06, 0xF6, 0x6B, 0x79, 0x70, 0xFD, 0xFF,
 852                                 0x86, 0x17, 0x18, 0x7B, 0xB9, 0xFF, 0xFD, 0xFF,
 853                         },
 854                         .len = 32,
 855                 },
 856 };
 857
 858 static struct fips_dev_self_test_vector
 859 SELF_TEST_AES192_CTR_test_vector = {
 860                 .name = "SELF_TEST_AES192_CTR_test_vector",
 861                 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 862
 863                 .iv = {
 864                         .data = {
 865                                 0x3F, 0x69, 0xA8, 0xCD, 0xE8, 0xF0, 0xEF, 0x40,
 866                                 0xB8, 0x7A, 0x4B, 0xED, 0x2B, 0xAF, 0xBF, 0x57
 867                         },
 868                         .len = 16,
 869                 },
 870                 .cipher = {
 871                         .algo = RTE_CRYPTO_CIPHER_AES_CTR,
 872                 },
 873                 .input = {
 874                         .data = {
 875                                 0x01, 0x0F, 0x10, 0x1F, 0x20, 0x1C, 0x0E, 0xB8,
 876                                 0xFB, 0x5C, 0xCD, 0xCC, 0x1F, 0xF9, 0xAF, 0x0B,
 877                                 0x95, 0x03, 0x74, 0x99, 0x49, 0xE7, 0x62, 0x55,
 878                                 0xDA, 0xEA, 0x13, 0x20, 0x1D, 0xC6, 0xCC, 0xCC,
 879                         },
 880                         .len = 32,
 881                 },
 882                 .key = {
 883                         .data = {
 884                                 0xCB, 0xC5, 0xED, 0x5B, 0xE7, 0x7C, 0xBD, 0x8C,
 885                                 0x50, 0xD9, 0x30, 0xF2, 0xB5, 0x6A, 0x0E, 0x5F,
 886                                 0xAA, 0xAE, 0xAD, 0xA2, 0x1F, 0x49, 0x52, 0xD4
 887                         },
 888                         .len = 24,
 889                 },
 890                 .output = {
 891                         .data = {
 892                                 0x4A, 0x6C, 0xC8, 0xCC, 0x96, 0x2A, 0x13, 0x84,
 893                                 0x1C, 0x36, 0x88, 0xE9, 0xE5, 0x94, 0x70, 0xB2,
 894                                 0x14, 0x5B, 0x13, 0x80, 0xEA, 0xD8, 0x8D, 0x37,
 895                                 0xFD, 0x70, 0xA8, 0x83, 0xE8, 0x2B, 0x88, 0x1E,
 896                         },
 897                         .len = 32,
 898                 },
 899 };
 900
 901 static struct fips_dev_self_test_vector
 902 SELF_TEST_AES256_CTR_test_vector = {
 903                 .name = "SELF_TEST_AES256_CTR_test_vector",
 904                 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 905
 906                 .iv = {
 907                         .data = {
 908                                 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
 909                                 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
 910                         },
 911                         .len = 16,
 912                 },
 913                 .cipher = {
 914                         .algo = RTE_CRYPTO_CIPHER_AES_CTR,
 915                 },
 916                 .input = {
 917                         .data = {
 918                                 0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,
 919                                 0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A,
 920                                 0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C,
 921                                 0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51,
 922                         },
 923                         .len = 32,
 924                 },
 925                 .key = {
 926                         .data = {
 927                                 0x60, 0x3D, 0xEB, 0x10, 0x15, 0xCA, 0x71, 0xBE,
 928                                 0x2B, 0x73, 0xAE, 0xF0, 0x85, 0x7D, 0x77, 0x81,
 929                                 0x1F, 0x35, 0x2C, 0x07, 0x3B, 0x61, 0x08, 0xD7,
 930                                 0x2D, 0x98, 0x10, 0xA3, 0x09, 0x14, 0xDF, 0xF4
 931                         },
 932                         .len = 32,
 933                 },
 934                 .output = {
 935                         .data = {
 936                                 0x60, 0x1E, 0xC3, 0x13, 0x77, 0x57, 0x89, 0xA5,
 937                                 0xB7, 0xA7, 0xF5, 0x04, 0xBB, 0xF3, 0xD2, 0x28,
 938                                 0xF4, 0x43, 0xE3, 0xCA, 0x4D, 0x62, 0xB5, 0x9A,
 939                                 0xCA, 0x84, 0xE9, 0x90, 0xCA, 0xCA, 0xF5, 0xC5,
 940                         },
 941                         .len = 32,
 942                 },
 943 };
 944
 945
 946 struct fips_dev_self_test_vector
 947 *self_test_vectors[] = {
 948                 &SELF_TEST_AES128_CBC_test_vector,
 949                 &SELF_TEST_AES192_CBC_test_vector,
 950                 &SELF_TEST_AES256_CBC_test_vector,
 951                 &SELF_TEST_3DES_2KEY_CBC_test_vector,
 952                 &SELF_TEST_3DES_3KEY_CBC_test_vector,
 953                 &SELF_TEST_AES128_CCM_test_vector,
 954                 &SELF_TEST_SHA1_HMAC_test_vector,
 955                 &SELF_TEST_SHA224_HMAC_test_vector,
 956                 &SELF_TEST_SHA256_HMAC_test_vector,
 957                 &SELF_TEST_SHA384_HMAC_test_vector,
 958                 &SELF_TEST_SHA512_HMAC_test_vector,
 959                 &SELF_TEST_AES_CMAC_test_vector,
 960                 &SELF_TEST_AES128_GCM_encrypt_test_vector,
 961                 &SELF_TEST_AES192_GCM_encrypt_test_vector,
 962                 &SELF_TEST_AES256_GCM_encrypt_test_vector,
 963                 &SELF_TEST_AES128_CTR_test_vector,
 964                 &SELF_TEST_AES192_CTR_test_vector,
 965                 &SELF_TEST_AES256_CTR_test_vector,
 966 };
 967
 968 struct fips_dev_auto_test_env {
 969         struct rte_mempool *mpool;
 970         struct rte_mempool *op_pool;
 971         struct rte_mempool *sess_pool;
 972         struct rte_mempool *sess_priv_pool;
 973         struct rte_mbuf *mbuf;
 974         struct rte_crypto_op *op;
 975 };
 976
 977 typedef int (*fips_dev_self_test_prepare_xform_t)(uint8_t,
 978                 struct rte_crypto_sym_xform *,
 979                 struct fips_dev_self_test_vector *,
 980                 uint32_t, uint8_t *,
 981                 uint32_t);
 982
 983 typedef int (*fips_dev_self_test_prepare_op_t)(struct rte_crypto_op *,
 984                 struct rte_mbuf *, struct rte_cryptodev_sym_session *,
 985                 uint32_t, struct fips_dev_self_test_vector *);
 986
 987 typedef int (*fips_dev_self_test_check_result_t)(struct rte_crypto_op *,
 988                 struct fips_dev_self_test_vector *, uint32_t);
 989
 990 struct fips_dev_self_test_ops {
 991         enum rte_crypto_sym_xform_type last_operation_type;
 992         fips_dev_self_test_prepare_xform_t prepare_xform;
 993         fips_dev_self_test_prepare_op_t prepare_op;
 994         fips_dev_self_test_check_result_t check_result;
 995 };
 996
 997 static int
 998 prepare_cipher_xform(uint8_t dev_id,
 999                 struct rte_crypto_sym_xform *xform,
1000                 struct fips_dev_self_test_vector *vec,
1001                 uint32_t dir,
1002                 uint8_t *key,
1003                 uint32_t neg_test)
1004 {
1005         const struct rte_cryptodev_symmetric_capability *cap;
1006         struct rte_cryptodev_sym_capability_idx cap_idx;
1007         struct rte_crypto_cipher_xform *cipher_xform = &xform->cipher;
1008
1009         memset(xform, 0, sizeof(*xform));
1010
1011         /** negative test, key is xored */
1012         if (neg_test) {
1013                 uint32_t i;
1014
1015                 for (i = 0; i < vec->key.len; i++)
1016                         key[i] ^= vec->key.data[i];
1017         } else
1018                 memcpy(key, vec->key.data, vec->key.len);
1019
1020         xform->type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1021
1022         cipher_xform->algo = vec->cipher.algo;
1023         cipher_xform->op = (dir == self_test_dir_enc_auth_gen) ?
1024                         RTE_CRYPTO_CIPHER_OP_ENCRYPT :
1025                         RTE_CRYPTO_CIPHER_OP_DECRYPT;
1026         cipher_xform->key.data = key;
1027         cipher_xform->key.length = vec->key.len;
1028         cipher_xform->iv.length = vec->iv.len;
1029         cipher_xform->iv.offset = IV_OFF;
1030
1031         cap_idx.algo.cipher = cipher_xform->algo;
1032         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1033
1034         cap = rte_cryptodev_sym_capability_get(dev_id, &cap_idx);
1035         if (!cap) {
1036                 RTE_LOG(ERR, PMD, "Failed to get capability for cdev %u\n",
1037                                 dev_id);
1038                 return -EACCES;
1039         }
1040
1041         if (rte_cryptodev_sym_capability_check_cipher(cap,
1042                         cipher_xform->key.length,
1043                         cipher_xform->iv.length) != 0) {
1044                 RTE_LOG(ERR, PMD, "PMD %s key length %u IV length %u\n",
1045                                 rte_cryptodev_name_get(dev_id),
1046                                 cipher_xform->key.length,
1047                                 cipher_xform->iv.length);
1048                 return -EACCES;
1049         }
1050
1051         return 0;
1052 }
1053
1054 static int
1055 prepare_auth_xform(uint8_t dev_id,
1056                 struct rte_crypto_sym_xform *xform,
1057                 struct fips_dev_self_test_vector *vec,
1058                 uint32_t dir,
1059                 uint8_t *key,
1060                 uint32_t neg_test)
1061 {
1062         const struct rte_cryptodev_symmetric_capability *cap;
1063         struct rte_cryptodev_sym_capability_idx cap_idx;
1064         struct rte_crypto_auth_xform *auth_xform = &xform->auth;
1065
1066         memset(xform, 0, sizeof(*xform));
1067
1068         /** negative test, key is xored */
1069         if (neg_test) {
1070                 uint32_t i;
1071
1072                 for (i = 0; i < vec->key.len; i++)
1073                         key[i] ^= vec->key.data[i];
1074         } else
1075                 memcpy(key, vec->key.data, vec->key.len);
1076
1077         xform->type = RTE_CRYPTO_SYM_XFORM_AUTH;
1078
1079         auth_xform->algo = vec->auth.algo;
1080         auth_xform->op = (dir == self_test_dir_enc_auth_gen) ?
1081                         RTE_CRYPTO_AUTH_OP_GENERATE :
1082                         RTE_CRYPTO_AUTH_OP_VERIFY;
1083         auth_xform->digest_length = vec->digest.len;
1084         auth_xform->key.data = key;
1085         auth_xform->key.length = vec->key.len;
1086
1087         cap_idx.algo.auth = auth_xform->algo;
1088         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1089
1090         cap = rte_cryptodev_sym_capability_get(dev_id, &cap_idx);
1091         if (!cap) {
1092                 RTE_LOG(ERR, PMD, "Failed to get capability for cdev %u\n",
1093                                 dev_id);
1094                 return -EACCES;
1095         }
1096
1097         if (rte_cryptodev_sym_capability_check_auth(cap,
1098                         auth_xform->key.length,
1099                         auth_xform->digest_length, 0) != 0) {
1100                 RTE_LOG(ERR, PMD, "PMD %s key length %u Digest length %u\n",
1101                                 rte_cryptodev_name_get(dev_id),
1102                                 auth_xform->key.length,
1103                                 auth_xform->digest_length);
1104                 return -EACCES;
1105         }
1106
1107         return 0;
1108 }
1109
1110 static int
1111 prepare_aead_xform(uint8_t dev_id,
1112                 struct rte_crypto_sym_xform *xform,
1113                 struct fips_dev_self_test_vector *vec,
1114                 uint32_t dir,
1115                 uint8_t *key,
1116                 uint32_t neg_test)
1117 {
1118         const struct rte_cryptodev_symmetric_capability *cap;
1119         struct rte_cryptodev_sym_capability_idx cap_idx;
1120         struct rte_crypto_aead_xform *aead_xform = &xform->aead;
1121
1122         memset(xform, 0, sizeof(*xform));
1123
1124         /** negative test, key is xored */
1125         if (neg_test) {
1126                 uint32_t i;
1127
1128                 for (i = 0; i < vec->key.len; i++)
1129                         key[i] ^= vec->key.data[i];
1130         } else
1131                 memcpy(key, vec->key.data, vec->key.len);
1132
1133         xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
1134
1135         aead_xform->algo = vec->aead.algo;
1136         aead_xform->op = (dir == self_test_dir_enc_auth_gen) ?
1137                         RTE_CRYPTO_AEAD_OP_ENCRYPT :
1138                         RTE_CRYPTO_AEAD_OP_DECRYPT;
1139         aead_xform->aad_length = vec->aead.aad.len;
1140         aead_xform->digest_length = vec->digest.len;
1141         aead_xform->iv.offset = IV_OFF;
1142         aead_xform->iv.length = vec->iv.len;
1143         aead_xform->key.data = key;
1144         aead_xform->key.length = vec->key.len;
1145
1146         cap_idx.algo.aead = aead_xform->algo;
1147         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
1148
1149         cap = rte_cryptodev_sym_capability_get(dev_id, &cap_idx);
1150         if (!cap) {
1151                 RTE_LOG(ERR, PMD, "Failed to get capability for cdev %u\n",
1152                                 dev_id);
1153                 return -EACCES;
1154         }
1155
1156         if (rte_cryptodev_sym_capability_check_aead(cap,
1157                         aead_xform->key.length,
1158                         aead_xform->digest_length, aead_xform->aad_length,
1159                         aead_xform->iv.length) != 0) {
1160                 RTE_LOG(ERR, PMD,
1161                         "PMD %s key_len %u tag_len %u aad_len %u iv_len %u\n",
1162                                 rte_cryptodev_name_get(dev_id),
1163                                 aead_xform->key.length,
1164                                 aead_xform->digest_length,
1165                                 aead_xform->aad_length,
1166                                 aead_xform->iv.length);
1167                 return -EACCES;
1168         }
1169
1170         return 0;
1171 }
1172
1173 static int
1174 prepare_cipher_op(struct rte_crypto_op *op,
1175                 struct rte_mbuf *mbuf,
1176                 struct rte_cryptodev_sym_session *session,
1177                 uint32_t dir,
1178                 struct fips_dev_self_test_vector *vec)
1179 {
1180         struct rte_crypto_sym_op *sym = op->sym;
1181         uint8_t *iv = rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFF);
1182         uint8_t *dst;
1183         const uint8_t *src;
1184         uint32_t len;
1185
1186         if (dir == self_test_dir_enc_auth_gen) {
1187                 src = vec->input.data;
1188                 len = vec->input.len;
1189         } else {
1190                 src = vec->output.data;
1191                 len = vec->output.len;
1192         }
1193
1194         sym->cipher.data.offset = 0;
1195         memcpy(iv, vec->iv.data, vec->iv.len);
1196
1197         dst = (uint8_t *)rte_pktmbuf_append(mbuf, len);
1198         if (!dst) {
1199                 RTE_LOG(ERR, PMD, "Error %i: MBUF too small\n", -ENOMEM);
1200                 return -ENOMEM;
1201         }
1202
1203         memcpy(dst, src, len);
1204
1205         sym->cipher.data.length = len;
1206
1207         rte_crypto_op_attach_sym_session(op, session);
1208
1209         return 0;
1210 }
1211
1212 static int
1213 prepare_auth_op(struct rte_crypto_op *op,
1214                 struct rte_mbuf *mbuf,
1215                 struct rte_cryptodev_sym_session *session,
1216                 uint32_t dir,
1217                 struct fips_dev_self_test_vector *vec)
1218 {
1219         struct rte_crypto_sym_op *sym = op->sym;
1220         uint8_t *dst;
1221
1222         if (vec->input.len + vec->digest.len > RTE_MBUF_MAX_NB_SEGS) {
1223                 RTE_LOG(ERR, PMD, "Error %i: Test data too long (%u).\n",
1224                                 -ENOMEM, vec->input.len + vec->digest.len);
1225                 return -ENOMEM;
1226         }
1227
1228         sym->auth.data.offset = 0;
1229
1230         dst = (uint8_t *)rte_pktmbuf_append(mbuf, vec->input.len +
1231                         vec->digest.len);
1232         if (!dst) {
1233                 RTE_LOG(ERR, PMD, "Error %i: MBUF too small\n", -ENOMEM);
1234                 return -ENOMEM;
1235         }
1236
1237         memcpy(dst, vec->input.data, vec->input.len);
1238         sym->auth.data.length = vec->input.len;
1239         sym->auth.digest.data = dst + vec->input.len;
1240         sym->auth.digest.phys_addr = rte_pktmbuf_iova_offset(mbuf,
1241                         vec->input.len);
1242
1243         if (dir == self_test_dir_dec_auth_verify)
1244                 memcpy(dst + vec->input.len, vec->digest.data, vec->digest.len);
1245
1246         rte_crypto_op_attach_sym_session(op, session);
1247
1248         return 0;
1249 }
1250
1251 static int
1252 prepare_aead_op(struct rte_crypto_op *op,
1253                 struct rte_mbuf *mbuf,
1254                 struct rte_cryptodev_sym_session *session,
1255                 uint32_t dir,
1256                 struct fips_dev_self_test_vector *vec)
1257 {
1258         struct rte_crypto_sym_op *sym = op->sym;
1259         uint8_t *iv = rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFF);
1260         uint8_t *dst;
1261         const uint8_t *src;
1262         uint32_t len;
1263
1264         if (dir == self_test_dir_enc_auth_gen) {
1265                 len = vec->input.len;
1266                 src = vec->input.data;
1267         } else {
1268                 len = vec->output.len;
1269                 src = vec->output.data;
1270         }
1271
1272         if (vec->aead.algo == RTE_CRYPTO_AEAD_AES_CCM)
1273                 memcpy(iv + 1, vec->iv.data, vec->iv.len);
1274         else
1275                 memcpy(iv, vec->iv.data, vec->iv.len);
1276
1277         if (len + vec->digest.len > RTE_MBUF_MAX_NB_SEGS) {
1278                 RTE_LOG(ERR, PMD, "Error %i: Test data too long (%u).\n",
1279                                 -ENOMEM, len + vec->digest.len);
1280                 return -ENOMEM;
1281         }
1282
1283         dst = (uint8_t *)rte_pktmbuf_append(mbuf, RTE_ALIGN_CEIL(len +
1284                         vec->digest.len, 16));
1285         if (!dst) {
1286                 RTE_LOG(ERR, PMD, "Error %i: MBUF too small\n", -ENOMEM);
1287                 return -ENOMEM;
1288         }
1289
1290         sym->m_src = mbuf;
1291         sym->aead.data.length = len;
1292         sym->aead.data.offset = 0;
1293         memcpy(dst, src, len);
1294
1295         sym->aead.digest.data = dst + vec->input.len;
1296         sym->aead.digest.phys_addr = rte_pktmbuf_iova_offset(mbuf,
1297                         vec->input.len);
1298         if (dir == self_test_dir_dec_auth_verify)
1299                 memcpy(sym->aead.digest.data, vec->digest.data, vec->digest.len);
1300
1301         len = (vec->aead.algo == RTE_CRYPTO_AEAD_AES_CCM) ?
1302                         (vec->aead.aad.len + AES_CCM_AAD_PAD_SIZE) :
1303                         vec->aead.aad.len;
1304
1305         dst = rte_malloc(NULL, len, 16);
1306         if (!dst) {
1307                 RTE_LOG(ERR, PMD, "Error %i: Not enough memory\n", -ENOMEM);
1308                 return -ENOMEM;
1309         }
1310
1311         sym->aead.aad.data = dst;
1312         sym->aead.aad.phys_addr = rte_malloc_virt2iova(dst);
1313         if (vec->aead.algo == RTE_CRYPTO_AEAD_AES_CCM)
1314                 memcpy(dst, vec->aead.aad.data,
1315                                 vec->aead.aad.len + AES_CCM_AAD_PAD_SIZE);
1316         else
1317                 memcpy(dst, vec->aead.aad.data,
1318                                 vec->aead.aad.len);
1319
1320         rte_crypto_op_attach_sym_session(op, session);
1321
1322         return 0;
1323 }
1324
1325 static int
1326 check_cipher_result(struct rte_crypto_op *op,
1327                 struct fips_dev_self_test_vector *vec,
1328                 uint32_t dir)
1329 {
1330         struct rte_mbuf *mbuf = op->sym->m_src;
1331         uint8_t *data;
1332         const uint8_t *src;
1333         uint32_t len, src_len;
1334         int ret;
1335
1336         if (!mbuf)
1337                 return -1;
1338
1339         if (dir == self_test_dir_enc_auth_gen) {
1340                 src = vec->output.data;
1341                 src_len = vec->output.len;
1342         } else {
1343                 src = vec->input.data;
1344                 src_len = vec->input.len;
1345         }
1346
1347         GET_MBUF_DATA(data, len, mbuf);
1348         if (!len)
1349                 return -1;
1350
1351         ret = memcmp(data, src, src_len);
1352         if (ret != 0)
1353                 return -1;
1354
1355         return 0;
1356 }
1357
1358 static int
1359 check_auth_result(struct rte_crypto_op *op,
1360                 struct fips_dev_self_test_vector *vec,
1361                 uint32_t dir)
1362 {
1363         struct rte_mbuf *mbuf = op->sym->m_src;
1364         uint8_t *data;
1365         uint32_t len;
1366         int ret;
1367
1368         if (mbuf == NULL)
1369                 return -1;
1370
1371         GET_MBUF_DATA(data, len, mbuf);
1372         if (!len)
1373                 return -1;
1374
1375         if (dir == self_test_dir_enc_auth_gen) {
1376                 data += vec->input.len;
1377                 ret = memcmp(data, vec->digest.data, vec->digest.len);
1378                 if (ret != 0)
1379                         return -1;
1380         }
1381
1382         return 0;
1383 }
1384
1385 static int
1386 check_aead_result(struct rte_crypto_op *op,
1387                 struct fips_dev_self_test_vector *vec,
1388                 uint32_t dir)
1389 {
1390         struct rte_mbuf *mbuf = op->sym->m_src;
1391         uint8_t *data;
1392         const uint8_t *src;
1393         uint32_t len, src_len;
1394         int ret;
1395
1396         if (!mbuf)
1397                 return -1;
1398
1399         rte_free(op->sym->aead.aad.data);
1400
1401         if (dir == self_test_dir_enc_auth_gen) {
1402                 src = vec->output.data;
1403                 src_len = vec->output.len;
1404         } else {
1405                 src = vec->input.data;
1406                 src_len = vec->input.len;
1407         }
1408
1409         GET_MBUF_DATA(data, len, mbuf);
1410         if (!len)
1411                 return -1;
1412
1413         ret = memcmp(data, src, src_len);
1414         if (ret != 0)
1415                 return -1;
1416
1417         if (dir == self_test_dir_enc_auth_gen) {
1418                 data += src_len;
1419                 ret = memcmp(data, vec->digest.data, vec->digest.len);
1420                 if (ret != 0)
1421                         return -1;
1422         }
1423
1424         return 0;
1425 }
1426
1427 static void
1428 init_test_op(struct fips_dev_self_test_ops *test_ops,
1429                 struct fips_dev_self_test_vector *vec)
1430 {
1431         if (test_ops->last_operation_type == vec->operation_type)
1432                 return;
1433
1434         switch (vec->operation_type) {
1435         case RTE_CRYPTO_SYM_XFORM_CIPHER:
1436                 test_ops->prepare_xform = prepare_cipher_xform;
1437                 test_ops->prepare_op = prepare_cipher_op;
1438                 test_ops->check_result = check_cipher_result;
1439                 break;
1440         case RTE_CRYPTO_SYM_XFORM_AUTH:
1441                 test_ops->prepare_xform = prepare_auth_xform;
1442                 test_ops->prepare_op = prepare_auth_op;
1443                 test_ops->check_result = check_auth_result;
1444                 break;
1445         case RTE_CRYPTO_SYM_XFORM_AEAD:
1446                 test_ops->prepare_xform = prepare_aead_xform;
1447                 test_ops->prepare_op = prepare_aead_op;
1448                 test_ops->check_result = check_aead_result;
1449                 break;
1450         default:
1451                 break;
1452         }
1453
1454         test_ops->last_operation_type = vec->operation_type;
1455 }
1456
1457 static int
1458 run_single_test(uint8_t dev_id,
1459                 struct fips_dev_self_test_vector *vec,
1460                 const struct fips_dev_self_test_ops *test_ops,
1461                 struct fips_dev_auto_test_env *env,
1462                 uint32_t dir,
1463                 uint32_t negative_test)
1464 {
1465         struct rte_crypto_sym_xform xform;
1466         struct rte_cryptodev_sym_session *sess;
1467         uint16_t n_deqd;
1468         uint8_t key[256];
1469         int ret;
1470
1471         __rte_crypto_op_reset(env->op, RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1472         rte_pktmbuf_reset(env->mbuf);
1473         env->op->sym->m_src = env->mbuf;
1474
1475         ret = test_ops->prepare_xform(dev_id, &xform, vec, dir, key,
1476                         negative_test);
1477         if (ret < 0) {
1478                 RTE_LOG(ERR, PMD, "Error %i: Prepare Xform\n", ret);
1479                 return ret;
1480         }
1481
1482         sess = rte_cryptodev_sym_session_create(env->sess_pool);
1483         if (!sess)
1484                 return -ENOMEM;
1485
1486         ret = rte_cryptodev_sym_session_init(dev_id,
1487                         sess, &xform, env->sess_priv_pool);
1488         if (ret < 0) {
1489                 RTE_LOG(ERR, PMD, "Error %i: Init session\n", ret);
1490                 return ret;
1491         }
1492
1493         ret = test_ops->prepare_op(env->op, env->mbuf, sess, dir, vec);
1494         if (ret < 0) {
1495                 RTE_LOG(ERR, PMD, "Error %i: Prepare op\n", ret);
1496                 return ret;
1497         }
1498
1499         if (rte_cryptodev_enqueue_burst(dev_id, 0, &env->op, 1) < 1) {
1500                 RTE_LOG(ERR, PMD, "Error: Failed enqueue\n");
1501                 return ret;
1502         }
1503
1504         do {
1505                 struct rte_crypto_op *deqd_op;
1506
1507                 n_deqd = rte_cryptodev_dequeue_burst(dev_id, 0, &deqd_op,
1508                                 1);
1509         } while (n_deqd == 0);
1510
1511         rte_cryptodev_sym_session_clear(dev_id, sess);
1512         rte_cryptodev_sym_session_free(sess);
1513
1514         if (env->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS)
1515                 return -1;
1516
1517         return test_ops->check_result(env->op, vec, dir);
1518 }
1519
1520
1521 static void
1522 fips_dev_auto_test_uninit(uint8_t dev_id,
1523                 struct fips_dev_auto_test_env *env)
1524 {
1525         rte_pktmbuf_free(env->mbuf);
1526         if (env->op)
1527                 rte_crypto_op_free(env->op);
1528         rte_mempool_free(env->mpool);
1529         rte_mempool_free(env->op_pool);
1530         rte_mempool_free(env->sess_pool);
1531         rte_mempool_free(env->sess_priv_pool);
1532
1533         rte_cryptodev_stop(dev_id);
1534 }
1535
1536 static int
1537 fips_dev_auto_test_init(uint8_t dev_id, struct fips_dev_auto_test_env *env)
1538 {
1539         struct rte_cryptodev_qp_conf qp_conf = {128, NULL, NULL};
1540         uint32_t sess_sz = rte_cryptodev_sym_get_private_session_size(dev_id);
1541         struct rte_cryptodev_config conf;
1542         char name[128];
1543         int ret;
1544
1545         conf.socket_id = rte_cryptodev_socket_id(dev_id);
1546         conf.nb_queue_pairs = 1;
1547         conf.ff_disable = 0;
1548
1549         ret = rte_cryptodev_configure(dev_id, &conf);
1550         if (ret < 0)
1551                 return ret;
1552
1553         memset(name, 0, 128);
1554         snprintf(name, 128, "%s%u", "SELF_TEST_MEMPOOL", dev_id);
1555
1556         memset(env, 0, sizeof(*env));
1557
1558         env->mpool = rte_pktmbuf_pool_create(name, 128, 0, 0,
1559                         UINT16_MAX, rte_cryptodev_socket_id(dev_id));
1560         if (!env->mpool) {
1561                 ret = -ENOMEM;
1562                 goto error_exit;
1563         }
1564
1565         memset(name, 0, 128);
1566         snprintf(name, 128, "%s%u", "SELF_TEST_OP_POOL", dev_id);
1567
1568         env->op_pool = rte_crypto_op_pool_create(
1569                         name,
1570                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
1571                         16, 0,
1572                         16,
1573                         rte_socket_id());
1574         if (!env->op_pool) {
1575                 ret = -ENOMEM;
1576                 goto error_exit;
1577         }
1578
1579         memset(name, 0, 128);
1580         snprintf(name, 128, "%s%u", "SELF_TEST_SESS_POOL", dev_id);
1581
1582         env->sess_pool = rte_cryptodev_sym_session_pool_create(name,
1583                         128, 0, 0, 0, rte_cryptodev_socket_id(dev_id));
1584         if (!env->sess_pool) {
1585                 ret = -ENOMEM;
1586                 goto error_exit;
1587         }
1588
1589         memset(name, 0, 128);
1590         snprintf(name, 128, "%s%u", "SELF_TEST_SESS_PRIV_POOL", dev_id);
1591
1592         env->sess_priv_pool = rte_mempool_create(name,
1593                         128, sess_sz, 0, 0, NULL, NULL, NULL,
1594                         NULL, rte_cryptodev_socket_id(dev_id), 0);
1595         if (!env->sess_priv_pool) {
1596                 ret = -ENOMEM;
1597                 goto error_exit;
1598         }
1599
1600         qp_conf.mp_session = env->sess_pool;
1601         qp_conf.mp_session_private = env->sess_priv_pool;
1602
1603         ret = rte_cryptodev_queue_pair_setup(dev_id, 0, &qp_conf,
1604                         rte_cryptodev_socket_id(dev_id));
1605         if (ret < 0)
1606                 goto error_exit;
1607
1608         env->mbuf = rte_pktmbuf_alloc(env->mpool);
1609         if (!env->mbuf) {
1610                 ret = -ENOMEM;
1611                 goto error_exit;
1612         }
1613
1614         env->op = rte_crypto_op_alloc(env->op_pool,
1615                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1616         if (!env->op) {
1617                 ret = -ENOMEM;
1618                 goto error_exit;
1619         }
1620
1621         ret = rte_cryptodev_start(dev_id);
1622         if (ret < 0)
1623                 goto error_exit;
1624
1625
1626         return 0;
1627
1628 error_exit:
1629
1630         fips_dev_auto_test_uninit(dev_id, env);
1631
1632         return ret;
1633 }
1634
1635 int
1636 fips_dev_self_test(uint8_t dev_id,
1637                 struct fips_dev_broken_test_config *config)
1638 {
1639         struct fips_dev_self_test_ops test_ops = {0};
1640         struct fips_dev_auto_test_env env;
1641         uint32_t i, j, negative_test;
1642         int ret;
1643
1644         ret = fips_dev_auto_test_init(dev_id, &env);
1645         if (ret < 0) {
1646                 RTE_LOG(ERR, PMD, "Failed to init self-test for PMD %u\n",
1647                                 dev_id);
1648                 return ret;
1649         }
1650
1651         for (i = 0; i < RTE_DIM(self_test_vectors); i++) {
1652                 struct fips_dev_self_test_vector *vec =
1653                                 self_test_vectors[i];
1654
1655                 init_test_op(&test_ops, vec);
1656
1657                 for (j = 0; j < self_test_dir_max; j++) {
1658                         if (!config)
1659                                 negative_test = 0;
1660                         else {
1661                                 if ((config->expect_fail_test_idx == i) &&
1662                                                 (config->expect_fail_dir == j))
1663                                         negative_test = 1;
1664                                 else
1665                                         negative_test = 0;
1666                         }
1667
1668                         RTE_LOG(INFO, PMD, "Testing (ID %u) %s %s%s...\n",
1669                                         i,
1670                                         vec->name,
1671                                         j == self_test_dir_enc_auth_gen ?
1672                                                         "Encrypt" : "Decrypt",
1673                                         negative_test ? " (Expect Fail)" : "");
1674
1675                         ret = run_single_test(dev_id, vec, &test_ops,
1676                                                 &env, j, negative_test);
1677                         switch (ret) {
1678                         case 0:
1679                                 if (!negative_test)
1680                                         break;
1681                                 ret = -1;
1682                                 RTE_LOG(ERR, PMD, "PMD %u Failed test %s %s\n",
1683                                         dev_id, vec->name,
1684                                         j == self_test_dir_enc_auth_gen ?
1685                                         "Encrypt" : "Decrypt");
1686                                 goto error_exit;
1687                         case -EACCES:
1688                                 RTE_LOG(ERR, PMD, "Not supported by %s. Skip\n",
1689                                         rte_cryptodev_name_get(dev_id));
1690                                 ret = 0;
1691                                 break;
1692                         default:
1693                                 RTE_LOG(ERR, PMD, "PMD %u Failed test %s %s\n",
1694                                         dev_id, vec->name,
1695                                         j == self_test_dir_enc_auth_gen ?
1696                                         "Encrypt" : "Decrypt");
1697                                 goto error_exit;
1698                         }
1699                 }
1700         }
1701
1702 error_exit:
1703         fips_dev_auto_test_uninit(dev_id, &env);
1704
1705         if (ret == 0) {
1706                 RTE_LOG(INFO, PMD, "PMD %u finished self-test successfully\n",
1707                                 dev_id);
1708         }
1709
1710         return ret;
1711 }