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 #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 (dir == self_test_dir_enc_auth_gen) {
1337                 src = vec->output.data;
1338                 src_len = vec->output.len;
1339         } else {
1340                 src = vec->input.data;
1341                 src_len = vec->input.len;
1342         }
1343
1344         GET_MBUF_DATA(data, len, mbuf);
1345         if (!data && !len)
1346                 return -1;
1347
1348         ret = memcmp(data, src, src_len);
1349         if (ret != 0)
1350                 return -1;
1351
1352         return 0;
1353 }
1354
1355 static int
1356 check_auth_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         uint32_t len;
1363         int ret;
1364
1365         GET_MBUF_DATA(data, len, mbuf);
1366         if (!data && !len)
1367                 return -1;
1368
1369         if (dir == self_test_dir_enc_auth_gen) {
1370                 data += vec->input.len;
1371                 ret = memcmp(data, vec->digest.data, vec->digest.len);
1372                 if (ret != 0)
1373                         return -1;
1374         }
1375
1376         return 0;
1377 }
1378
1379 static int
1380 check_aead_result(struct rte_crypto_op *op,
1381                 struct fips_dev_self_test_vector *vec,
1382                 uint32_t dir)
1383 {
1384         struct rte_mbuf *mbuf = op->sym->m_src;
1385         uint8_t *data;
1386         const uint8_t *src;
1387         uint32_t len, src_len;
1388         int ret;
1389
1390         if (op->sym->aead.aad.data)
1391                 rte_free(op->sym->aead.aad.data);
1392
1393         if (dir == self_test_dir_enc_auth_gen) {
1394                 src = vec->output.data;
1395                 src_len = vec->output.len;
1396         } else {
1397                 src = vec->input.data;
1398                 src_len = vec->input.len;
1399         }
1400
1401         GET_MBUF_DATA(data, len, mbuf);
1402         if (!data && !len)
1403                 return -1;
1404
1405         ret = memcmp(data, src, src_len);
1406         if (ret != 0)
1407                 return -1;
1408
1409         if (dir == self_test_dir_enc_auth_gen) {
1410                 data += src_len;
1411                 ret = memcmp(data, vec->digest.data, vec->digest.len);
1412                 if (ret != 0)
1413                         return -1;
1414         }
1415
1416         return 0;
1417 }
1418
1419 static void
1420 init_test_op(struct fips_dev_self_test_ops *test_ops,
1421                 struct fips_dev_self_test_vector *vec)
1422 {
1423         if (test_ops->last_operation_type == vec->operation_type)
1424                 return;
1425
1426         switch (vec->operation_type) {
1427         case RTE_CRYPTO_SYM_XFORM_CIPHER:
1428                 test_ops->prepare_xform = prepare_cipher_xform;
1429                 test_ops->prepare_op = prepare_cipher_op;
1430                 test_ops->check_result = check_cipher_result;
1431                 break;
1432         case RTE_CRYPTO_SYM_XFORM_AUTH:
1433                 test_ops->prepare_xform = prepare_auth_xform;
1434                 test_ops->prepare_op = prepare_auth_op;
1435                 test_ops->check_result = check_auth_result;
1436                 break;
1437         case RTE_CRYPTO_SYM_XFORM_AEAD:
1438                 test_ops->prepare_xform = prepare_aead_xform;
1439                 test_ops->prepare_op = prepare_aead_op;
1440                 test_ops->check_result = check_aead_result;
1441                 break;
1442         default:
1443                 break;
1444         }
1445
1446         test_ops->last_operation_type = vec->operation_type;
1447 }
1448
1449 static int
1450 run_single_test(uint8_t dev_id,
1451                 struct fips_dev_self_test_vector *vec,
1452                 const struct fips_dev_self_test_ops *test_ops,
1453                 struct fips_dev_auto_test_env *env,
1454                 uint32_t dir,
1455                 uint32_t negative_test)
1456 {
1457         struct rte_crypto_sym_xform xform;
1458         struct rte_cryptodev_sym_session *sess;
1459         uint16_t n_deqd;
1460         uint8_t key[256];
1461         int ret;
1462
1463         __rte_crypto_op_reset(env->op, RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1464         rte_pktmbuf_reset(env->mbuf);
1465         env->op->sym->m_src = env->mbuf;
1466
1467         ret = test_ops->prepare_xform(dev_id, &xform, vec, dir, key,
1468                         negative_test);
1469         if (ret < 0) {
1470                 RTE_LOG(ERR, PMD, "Error %i: Prepare Xform\n", ret);
1471                 return ret;
1472         }
1473
1474         sess = rte_cryptodev_sym_session_create(env->sess_pool);
1475         if (!sess)
1476                 return -ENOMEM;
1477
1478         ret = rte_cryptodev_sym_session_init(dev_id,
1479                         sess, &xform, env->sess_priv_pool);
1480         if (ret < 0) {
1481                 RTE_LOG(ERR, PMD, "Error %i: Init session\n", ret);
1482                 return ret;
1483         }
1484
1485         ret = test_ops->prepare_op(env->op, env->mbuf, sess, dir, vec);
1486         if (ret < 0) {
1487                 RTE_LOG(ERR, PMD, "Error %i: Prepare op\n", ret);
1488                 return ret;
1489         }
1490
1491         if (rte_cryptodev_enqueue_burst(dev_id, 0, &env->op, 1) < 1) {
1492                 RTE_LOG(ERR, PMD, "Error: Failed enqueue\n");
1493                 return ret;
1494         }
1495
1496         do {
1497                 struct rte_crypto_op *deqd_op;
1498
1499                 n_deqd = rte_cryptodev_dequeue_burst(dev_id, 0, &deqd_op,
1500                                 1);
1501         } while (n_deqd == 0);
1502
1503         rte_cryptodev_sym_session_clear(dev_id, sess);
1504         rte_cryptodev_sym_session_free(sess);
1505
1506         if (env->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS)
1507                 return -1;
1508
1509         return test_ops->check_result(env->op, vec, dir);
1510 }
1511
1512
1513 static void
1514 fips_dev_auto_test_uninit(uint8_t dev_id,
1515                 struct fips_dev_auto_test_env *env)
1516 {
1517         struct rte_cryptodev *dev = rte_cryptodev_pmd_get_dev(dev_id);
1518         uint32_t i;
1519
1520         if (!dev)
1521                 return;
1522
1523         if (env->mbuf)
1524                 rte_pktmbuf_free(env->mbuf);
1525         if (env->op)
1526                 rte_crypto_op_free(env->op);
1527         if (env->mpool)
1528                 rte_mempool_free(env->mpool);
1529         if (env->op_pool)
1530                 rte_mempool_free(env->op_pool);
1531         if (env->sess_pool)
1532                 rte_mempool_free(env->sess_pool);
1533         if (env->sess_priv_pool)
1534                 rte_mempool_free(env->sess_priv_pool);
1535
1536         if (dev->data->dev_started)
1537                 rte_cryptodev_stop(dev_id);
1538
1539         if (dev->data->nb_queue_pairs) {
1540                 for (i = 0; i < dev->data->nb_queue_pairs; i++)
1541                         (*dev->dev_ops->queue_pair_release)(dev, i);
1542                 dev->data->nb_queue_pairs = 0;
1543                 rte_free(dev->data->queue_pairs);
1544                 dev->data->queue_pairs = NULL;
1545         }
1546 }
1547
1548 static int
1549 fips_dev_auto_test_init(uint8_t dev_id, struct fips_dev_auto_test_env *env)
1550 {
1551         struct rte_cryptodev_config conf = {rte_cryptodev_socket_id(dev_id), 1};
1552         struct rte_cryptodev_qp_conf qp_conf = {128, NULL, NULL};
1553         uint32_t sess_sz = rte_cryptodev_sym_get_private_session_size(dev_id);
1554         char name[128];
1555         int ret;
1556
1557         ret = rte_cryptodev_configure(dev_id, &conf);
1558         if (ret < 0)
1559                 return ret;
1560
1561         memset(name, 0, 128);
1562         snprintf(name, 128, "%s%u", "SELF_TEST_MEMPOOL", dev_id);
1563
1564         memset(env, 0, sizeof(*env));
1565
1566         env->mpool = rte_pktmbuf_pool_create(name, 128, 0, 0,
1567                         UINT16_MAX, rte_cryptodev_socket_id(dev_id));
1568         if (!env->mpool) {
1569                 ret = -ENOMEM;
1570                 goto error_exit;
1571         }
1572
1573         memset(name, 0, 128);
1574         snprintf(name, 128, "%s%u", "SELF_TEST_OP_POOL", dev_id);
1575
1576         env->op_pool = rte_crypto_op_pool_create(
1577                         name,
1578                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
1579                         16, 0,
1580                         16,
1581                         rte_socket_id());
1582         if (!env->op_pool) {
1583                 ret = -ENOMEM;
1584                 goto error_exit;
1585         }
1586
1587         memset(name, 0, 128);
1588         snprintf(name, 128, "%s%u", "SELF_TEST_SESS_POOL", dev_id);
1589
1590         env->sess_pool = rte_cryptodev_sym_session_pool_create(name,
1591                         128, 0, 0, 0, rte_cryptodev_socket_id(dev_id));
1592         if (!env->sess_pool) {
1593                 ret = -ENOMEM;
1594                 goto error_exit;
1595         }
1596
1597         memset(name, 0, 128);
1598         snprintf(name, 128, "%s%u", "SELF_TEST_SESS_PRIV_POOL", dev_id);
1599
1600         env->sess_priv_pool = rte_mempool_create(name,
1601                         128, sess_sz, 0, 0, NULL, NULL, NULL,
1602                         NULL, rte_cryptodev_socket_id(dev_id), 0);
1603         if (!env->sess_priv_pool) {
1604                 ret = -ENOMEM;
1605                 goto error_exit;
1606         }
1607
1608         qp_conf.mp_session = env->sess_pool;
1609         qp_conf.mp_session_private = env->sess_priv_pool;
1610
1611         ret = rte_cryptodev_queue_pair_setup(dev_id, 0, &qp_conf,
1612                         rte_cryptodev_socket_id(dev_id));
1613         if (ret < 0)
1614                 goto error_exit;
1615
1616         env->mbuf = rte_pktmbuf_alloc(env->mpool);
1617         if (!env->mbuf) {
1618                 ret = -ENOMEM;
1619                 goto error_exit;
1620         }
1621
1622         env->op = rte_crypto_op_alloc(env->op_pool,
1623                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1624         if (!env->op) {
1625                 ret = -ENOMEM;
1626                 goto error_exit;
1627         }
1628
1629         ret = rte_cryptodev_start(dev_id);
1630         if (ret < 0)
1631                 goto error_exit;
1632
1633
1634         return 0;
1635
1636 error_exit:
1637
1638         fips_dev_auto_test_uninit(dev_id, env);
1639
1640         return ret;
1641 }
1642
1643 int
1644 fips_dev_self_test(uint8_t dev_id,
1645                 struct fips_dev_broken_test_config *config)
1646 {
1647         struct fips_dev_self_test_ops test_ops = {0};
1648         struct fips_dev_auto_test_env env;
1649         uint32_t i, j, negative_test;
1650         int ret;
1651
1652         ret = fips_dev_auto_test_init(dev_id, &env);
1653         if (ret < 0) {
1654                 RTE_LOG(ERR, PMD, "Failed to init self-test for PMD %u\n",
1655                                 dev_id);
1656                 return ret;
1657         }
1658
1659         for (i = 0; i < RTE_DIM(self_test_vectors); i++) {
1660                 struct fips_dev_self_test_vector *vec =
1661                                 self_test_vectors[i];
1662
1663                 init_test_op(&test_ops, vec);
1664
1665                 for (j = 0; j < self_test_dir_max; j++) {
1666                         if (!config)
1667                                 negative_test = 0;
1668                         else {
1669                                 if ((config->expect_fail_test_idx == i) &&
1670                                                 (config->expect_fail_dir == j))
1671                                         negative_test = 1;
1672                                 else
1673                                         negative_test = 0;
1674                         }
1675
1676                         RTE_LOG(INFO, PMD, "Testing (ID %u) %s %s%s...\n",
1677                                         i,
1678                                         vec->name,
1679                                         j == self_test_dir_enc_auth_gen ?
1680                                                         "Encrypt" : "Decrypt",
1681                                         negative_test ? " (Expect Fail)" : "");
1682
1683                         ret = run_single_test(dev_id, vec, &test_ops,
1684                                                 &env, j, negative_test);
1685                         switch (ret) {
1686                         case 0:
1687                                 if (!negative_test)
1688                                         break;
1689                                 ret = -1;
1690                                 RTE_LOG(ERR, PMD, "PMD %u Failed test %s %s\n",
1691                                         dev_id, vec->name,
1692                                         j == self_test_dir_enc_auth_gen ?
1693                                         "Encrypt" : "Decrypt");
1694                                 goto error_exit;
1695                         case -EACCES:
1696                                 RTE_LOG(ERR, PMD, "Not supported by %s. Skip\n",
1697                                         rte_cryptodev_name_get(dev_id));
1698                                 ret = 0;
1699                                 break;
1700                         default:
1701                                 RTE_LOG(ERR, PMD, "PMD %u Failed test %s %s\n",
1702                                         dev_id, vec->name,
1703                                         j == self_test_dir_enc_auth_gen ?
1704                                         "Encrypt" : "Decrypt");
1705                                 goto error_exit;
1706                         }
1707                 }
1708         }
1709
1710 error_exit:
1711         fips_dev_auto_test_uninit(dev_id, &env);
1712
1713         if (ret == 0) {
1714                 RTE_LOG(INFO, PMD, "PMD %u finished self-test successfully\n",
1715                                 dev_id);
1716         }
1717
1718         return ret;
1719 }