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