examples/fips_validation/main.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Intel Corporation
   3  */
   4
   5 #include <sys/stat.h>
   6 #include <getopt.h>
   7 #include <dirent.h>
   8
   9 #include <rte_cryptodev.h>
  10 #include <rte_cryptodev_pmd.h>
  11 #include <rte_mempool.h>
  12 #include <rte_mbuf.h>
  13 #include <rte_string_fns.h>
  14
  15 #include "fips_validation.h"
  16
  17 #define REQ_FILE_PATH_KEYWORD   "req-file"
  18 #define RSP_FILE_PATH_KEYWORD   "rsp-file"
  19 #define FOLDER_KEYWORD          "path-is-folder"
  20 #define CRYPTODEV_KEYWORD       "cryptodev"
  21 #define CRYPTODEV_ID_KEYWORD    "cryptodev-id"
  22
  23 struct fips_test_vector vec;
  24 struct fips_test_interim_info info;
  25
  26 struct cryptodev_fips_validate_env {
  27         const char *req_path;
  28         const char *rsp_path;
  29         uint32_t is_path_folder;
  30         uint32_t dev_id;
  31         struct rte_mempool *mpool;
  32         struct rte_mempool *sess_mpool;
  33         struct rte_mempool *sess_priv_mpool;
  34         struct rte_mempool *op_pool;
  35         struct rte_mbuf *mbuf;
  36         struct rte_crypto_op *op;
  37         struct rte_cryptodev_sym_session *sess;
  38 } env;
  39
  40 static int
  41 cryptodev_fips_validate_app_int(void)
  42 {
  43         struct rte_cryptodev_config conf = {rte_socket_id(), 1};
  44         struct rte_cryptodev_qp_conf qp_conf = {128, NULL, NULL};
  45         uint32_t sess_sz = rte_cryptodev_sym_get_private_session_size(
  46                         env.dev_id);
  47         int ret;
  48
  49         ret = rte_cryptodev_configure(env.dev_id, &conf);
  50         if (ret < 0)
  51                 return ret;
  52
  53         env.mpool = rte_pktmbuf_pool_create("FIPS_MEMPOOL", 128, 0, 0,
  54                         UINT16_MAX, rte_socket_id());
  55         if (!env.mpool)
  56                 return ret;
  57
  58         ret = rte_cryptodev_queue_pair_setup(env.dev_id, 0, &qp_conf,
  59                         rte_socket_id());
  60         if (ret < 0)
  61                 return ret;
  62
  63         ret = -ENOMEM;
  64
  65         env.sess_mpool = rte_cryptodev_sym_session_pool_create(
  66                         "FIPS_SESS_MEMPOOL", 16, 0, 0, 0, rte_socket_id());
  67         if (!env.sess_mpool)
  68                 goto error_exit;
  69
  70         env.sess_priv_mpool = rte_mempool_create("FIPS_SESS_PRIV_MEMPOOL",
  71                         16, sess_sz, 0, 0, NULL, NULL, NULL,
  72                         NULL, rte_socket_id(), 0);
  73         if (!env.sess_priv_mpool)
  74                 goto error_exit;
  75
  76         env.op_pool = rte_crypto_op_pool_create(
  77                         "FIPS_OP_POOL",
  78                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
  79                         1, 0,
  80                         16,
  81                         rte_socket_id());
  82         if (!env.op_pool)
  83                 goto error_exit;
  84
  85         env.mbuf = rte_pktmbuf_alloc(env.mpool);
  86         if (!env.mbuf)
  87                 goto error_exit;
  88
  89         env.op = rte_crypto_op_alloc(env.op_pool, RTE_CRYPTO_OP_TYPE_SYMMETRIC);
  90         if (!env.op)
  91                 goto error_exit;
  92
  93         qp_conf.mp_session = env.sess_mpool;
  94         qp_conf.mp_session_private = env.sess_priv_mpool;
  95
  96         ret = rte_cryptodev_queue_pair_setup(env.dev_id, 0, &qp_conf,
  97                         rte_socket_id());
  98         if (ret < 0)
  99                 goto error_exit;
 100
 101         return 0;
 102
 103 error_exit:
 104
 105         rte_mempool_free(env.mpool);
 106         if (env.sess_mpool)
 107                 rte_mempool_free(env.sess_mpool);
 108         if (env.sess_priv_mpool)
 109                 rte_mempool_free(env.sess_priv_mpool);
 110         if (env.op_pool)
 111                 rte_mempool_free(env.op_pool);
 112
 113         return ret;
 114 }
 115
 116 static void
 117 cryptodev_fips_validate_app_uninit(void)
 118 {
 119         rte_pktmbuf_free(env.mbuf);
 120         rte_crypto_op_free(env.op);
 121         rte_cryptodev_sym_session_clear(env.dev_id, env.sess);
 122         rte_cryptodev_sym_session_free(env.sess);
 123         rte_mempool_free(env.mpool);
 124         rte_mempool_free(env.sess_mpool);
 125         rte_mempool_free(env.sess_priv_mpool);
 126         rte_mempool_free(env.op_pool);
 127 }
 128
 129 static int
 130 fips_test_one_file(void);
 131
 132 static int
 133 parse_cryptodev_arg(char *arg)
 134 {
 135         int id = rte_cryptodev_get_dev_id(arg);
 136
 137         if (id < 0) {
 138                 RTE_LOG(ERR, USER1, "Error %i: invalid cryptodev name %s\n",
 139                                 id, arg);
 140                 return id;
 141         }
 142
 143         env.dev_id = (uint32_t)id;
 144
 145         return 0;
 146 }
 147
 148 static int
 149 parse_cryptodev_id_arg(char *arg)
 150 {
 151         uint32_t cryptodev_id;
 152
 153         if (parser_read_uint32(&cryptodev_id, arg) < 0) {
 154                 RTE_LOG(ERR, USER1, "Error %i: invalid cryptodev id %s\n",
 155                                 -EINVAL, arg);
 156                 return -1;
 157         }
 158
 159
 160         if (!rte_cryptodev_pmd_is_valid_dev(cryptodev_id)) {
 161                 RTE_LOG(ERR, USER1, "Error %i: invalid cryptodev id %s\n",
 162                                 cryptodev_id, arg);
 163                 return -1;
 164         }
 165
 166         env.dev_id = (uint32_t)cryptodev_id;
 167
 168         return 0;
 169 }
 170
 171 static void
 172 cryptodev_fips_validate_usage(const char *prgname)
 173 {
 174         printf("%s [EAL options] --\n"
 175                 "  --%s: REQUEST-FILE-PATH\n"
 176                 "  --%s: RESPONSE-FILE-PATH\n"
 177                 "  --%s: indicating both paths are folders\n"
 178                 "  --%s: CRYPTODEV-NAME\n"
 179                 "  --%s: CRYPTODEV-ID-NAME\n",
 180                 prgname, REQ_FILE_PATH_KEYWORD, RSP_FILE_PATH_KEYWORD,
 181                 FOLDER_KEYWORD, CRYPTODEV_KEYWORD, CRYPTODEV_ID_KEYWORD);
 182 }
 183
 184 static int
 185 cryptodev_fips_validate_parse_args(int argc, char **argv)
 186 {
 187         int opt, ret;
 188         char *prgname = argv[0];
 189         char **argvopt;
 190         int option_index;
 191         struct option lgopts[] = {
 192                         {REQ_FILE_PATH_KEYWORD, required_argument, 0, 0},
 193                         {RSP_FILE_PATH_KEYWORD, required_argument, 0, 0},
 194                         {FOLDER_KEYWORD, no_argument, 0, 0},
 195                         {CRYPTODEV_KEYWORD, required_argument, 0, 0},
 196                         {CRYPTODEV_ID_KEYWORD, required_argument, 0, 0},
 197                         {NULL, 0, 0, 0}
 198         };
 199
 200         argvopt = argv;
 201
 202         while ((opt = getopt_long(argc, argvopt, "s:",
 203                                   lgopts, &option_index)) != EOF) {
 204
 205                 switch (opt) {
 206                 case 0:
 207                         if (strcmp(lgopts[option_index].name,
 208                                         REQ_FILE_PATH_KEYWORD) == 0)
 209                                 env.req_path = optarg;
 210                         else if (strcmp(lgopts[option_index].name,
 211                                         RSP_FILE_PATH_KEYWORD) == 0)
 212                                 env.rsp_path = optarg;
 213                         else if (strcmp(lgopts[option_index].name,
 214                                         FOLDER_KEYWORD) == 0)
 215                                 env.is_path_folder = 1;
 216                         else if (strcmp(lgopts[option_index].name,
 217                                         CRYPTODEV_KEYWORD) == 0) {
 218                                 ret = parse_cryptodev_arg(optarg);
 219                                 if (ret < 0) {
 220                                         cryptodev_fips_validate_usage(prgname);
 221                                         return -EINVAL;
 222                                 }
 223                         } else if (strcmp(lgopts[option_index].name,
 224                                         CRYPTODEV_ID_KEYWORD) == 0) {
 225                                 ret = parse_cryptodev_id_arg(optarg);
 226                                 if (ret < 0) {
 227                                         cryptodev_fips_validate_usage(prgname);
 228                                         return -EINVAL;
 229                                 }
 230                         } else {
 231                                 cryptodev_fips_validate_usage(prgname);
 232                                 return -EINVAL;
 233                         }
 234                         break;
 235                 default:
 236                         return -1;
 237                 }
 238         }
 239
 240         if (env.req_path == NULL || env.rsp_path == NULL ||
 241                         env.dev_id == UINT32_MAX) {
 242                 cryptodev_fips_validate_usage(prgname);
 243                 return -EINVAL;
 244         }
 245
 246         return 0;
 247 }
 248
 249 int
 250 main(int argc, char *argv[])
 251 {
 252         int ret;
 253
 254         ret = rte_eal_init(argc, argv);
 255         if (ret < 0) {
 256                 RTE_LOG(ERR, USER1, "Error %i: Failed init\n", ret);
 257                 return -1;
 258         }
 259
 260         argc -= ret;
 261         argv += ret;
 262
 263         ret = cryptodev_fips_validate_parse_args(argc, argv);
 264         if (ret < 0)
 265                 rte_exit(EXIT_FAILURE, "Failed to parse arguments!\n");
 266
 267         ret = cryptodev_fips_validate_app_int();
 268         if (ret < 0) {
 269                 RTE_LOG(ERR, USER1, "Error %i: Failed init\n", ret);
 270                 return -1;
 271         }
 272
 273         if (!env.is_path_folder) {
 274                 printf("Processing file %s... ", env.req_path);
 275
 276                 ret = fips_test_init(env.req_path, env.rsp_path,
 277                         rte_cryptodev_name_get(env.dev_id));
 278                 if (ret < 0) {
 279                         RTE_LOG(ERR, USER1, "Error %i: Failed test %s\n",
 280                                         ret, env.req_path);
 281                         goto exit;
 282                 }
 283
 284
 285                 ret = fips_test_one_file();
 286                 if (ret < 0) {
 287                         RTE_LOG(ERR, USER1, "Error %i: Failed test %s\n",
 288                                         ret, env.req_path);
 289                         goto exit;
 290                 }
 291
 292                 printf("Done\n");
 293
 294         } else {
 295                 struct dirent *dir;
 296                 DIR *d_req, *d_rsp;
 297                 char req_path[1024];
 298                 char rsp_path[1024];
 299
 300                 d_req = opendir(env.req_path);
 301                 if (!d_req) {
 302                         RTE_LOG(ERR, USER1, "Error %i: Path %s not exist\n",
 303                                         -EINVAL, env.req_path);
 304                         goto exit;
 305                 }
 306
 307                 d_rsp = opendir(env.rsp_path);
 308                 if (!d_rsp) {
 309                         ret = mkdir(env.rsp_path, 0700);
 310                         if (ret == 0)
 311                                 d_rsp = opendir(env.rsp_path);
 312                         else {
 313                                 RTE_LOG(ERR, USER1, "Error %i: Invalid %s\n",
 314                                                 -EINVAL, env.rsp_path);
 315                                 goto exit;
 316                         }
 317                 }
 318                 closedir(d_rsp);
 319
 320                 while ((dir = readdir(d_req)) != NULL) {
 321                         if (strstr(dir->d_name, "req") == NULL)
 322                                 continue;
 323
 324                         snprintf(req_path, 1023, "%s/%s", env.req_path,
 325                                         dir->d_name);
 326                         snprintf(rsp_path, 1023, "%s/%s", env.rsp_path,
 327                                         dir->d_name);
 328                         strlcpy(strstr(rsp_path, "req"), "rsp", 4);
 329
 330                         printf("Processing file %s... ", req_path);
 331
 332                         ret = fips_test_init(req_path, rsp_path,
 333                         rte_cryptodev_name_get(env.dev_id));
 334                         if (ret < 0) {
 335                                 RTE_LOG(ERR, USER1, "Error %i: Failed test %s\n",
 336                                                 ret, req_path);
 337                                 break;
 338                         }
 339
 340                         ret = fips_test_one_file();
 341                         if (ret < 0) {
 342                                 RTE_LOG(ERR, USER1, "Error %i: Failed test %s\n",
 343                                                 ret, req_path);
 344                                 break;
 345                         }
 346
 347                         printf("Done\n");
 348                 }
 349
 350                 closedir(d_req);
 351         }
 352
 353
 354 exit:
 355         fips_test_clear();
 356         cryptodev_fips_validate_app_uninit();
 357
 358         return ret;
 359
 360 }
 361
 362 #define IV_OFF (sizeof(struct rte_crypto_op) + sizeof(struct rte_crypto_sym_op))
 363 #define CRYPTODEV_FIPS_MAX_RETRIES      16
 364
 365 typedef int (*fips_test_one_case_t)(void);
 366 typedef int (*fips_prepare_op_t)(void);
 367 typedef int (*fips_prepare_xform_t)(struct rte_crypto_sym_xform *);
 368
 369 struct fips_test_ops {
 370         fips_prepare_xform_t prepare_xform;
 371         fips_prepare_op_t prepare_op;
 372         fips_test_one_case_t test;
 373 } test_ops;
 374
 375 static int
 376 prepare_cipher_op(void)
 377 {
 378         struct rte_crypto_sym_op *sym = env.op->sym;
 379         uint8_t *iv = rte_crypto_op_ctod_offset(env.op, uint8_t *, IV_OFF);
 380
 381         __rte_crypto_op_reset(env.op, RTE_CRYPTO_OP_TYPE_SYMMETRIC);
 382         rte_pktmbuf_reset(env.mbuf);
 383
 384         sym->m_src = env.mbuf;
 385         sym->cipher.data.offset = 0;
 386
 387         memcpy(iv, vec.iv.val, vec.iv.len);
 388
 389         if (info.op == FIPS_TEST_ENC_AUTH_GEN) {
 390                 uint8_t *pt;
 391
 392                 if (vec.pt.len > RTE_MBUF_MAX_NB_SEGS) {
 393                         RTE_LOG(ERR, USER1, "PT len %u\n", vec.pt.len);
 394                         return -EPERM;
 395                 }
 396
 397                 pt = (uint8_t *)rte_pktmbuf_append(env.mbuf, vec.pt.len);
 398
 399                 if (!pt) {
 400                         RTE_LOG(ERR, USER1, "Error %i: MBUF too small\n",
 401                                         -ENOMEM);
 402                         return -ENOMEM;
 403                 }
 404
 405                 memcpy(pt, vec.pt.val, vec.pt.len);
 406                 sym->cipher.data.length = vec.pt.len;
 407
 408         } else {
 409                 uint8_t *ct;
 410
 411                 if (vec.ct.len > RTE_MBUF_MAX_NB_SEGS) {
 412                         RTE_LOG(ERR, USER1, "CT len %u\n", vec.ct.len);
 413                         return -EPERM;
 414                 }
 415
 416                 ct = (uint8_t *)rte_pktmbuf_append(env.mbuf, vec.ct.len);
 417
 418                 if (!ct) {
 419                         RTE_LOG(ERR, USER1, "Error %i: MBUF too small\n",
 420                                         -ENOMEM);
 421                         return -ENOMEM;
 422                 }
 423
 424                 memcpy(ct, vec.ct.val, vec.ct.len);
 425                 sym->cipher.data.length = vec.ct.len;
 426         }
 427
 428         rte_crypto_op_attach_sym_session(env.op, env.sess);
 429
 430         return 0;
 431 }
 432
 433 static int
 434 prepare_auth_op(void)
 435 {
 436         struct rte_crypto_sym_op *sym = env.op->sym;
 437
 438         __rte_crypto_op_reset(env.op, RTE_CRYPTO_OP_TYPE_SYMMETRIC);
 439         rte_pktmbuf_reset(env.mbuf);
 440
 441         sym->m_src = env.mbuf;
 442         sym->auth.data.offset = 0;
 443
 444         if (info.op == FIPS_TEST_ENC_AUTH_GEN) {
 445                 uint8_t *pt;
 446
 447                 if (vec.pt.len > RTE_MBUF_MAX_NB_SEGS) {
 448                         RTE_LOG(ERR, USER1, "PT len %u\n", vec.pt.len);
 449                         return -EPERM;
 450                 }
 451
 452                 pt = (uint8_t *)rte_pktmbuf_append(env.mbuf, vec.pt.len +
 453                                 vec.cipher_auth.digest.len);
 454
 455                 if (!pt) {
 456                         RTE_LOG(ERR, USER1, "Error %i: MBUF too small\n",
 457                                         -ENOMEM);
 458                         return -ENOMEM;
 459                 }
 460
 461                 memcpy(pt, vec.pt.val, vec.pt.len);
 462                 sym->auth.data.length = vec.pt.len;
 463                 sym->auth.digest.data = pt + vec.pt.len;
 464                 sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
 465                                 env.mbuf, vec.pt.len);
 466
 467         } else {
 468                 uint8_t *ct;
 469
 470                 if (vec.ct.len > RTE_MBUF_MAX_NB_SEGS) {
 471                         RTE_LOG(ERR, USER1, "CT len %u\n", vec.ct.len);
 472                         return -EPERM;
 473                 }
 474
 475                 ct = (uint8_t *)rte_pktmbuf_append(env.mbuf,
 476                                 vec.ct.len + vec.cipher_auth.digest.len);
 477
 478                 if (!ct) {
 479                         RTE_LOG(ERR, USER1, "Error %i: MBUF too small\n",
 480                                         -ENOMEM);
 481                         return -ENOMEM;
 482                 }
 483
 484                 memcpy(ct, vec.ct.val, vec.ct.len);
 485                 sym->auth.data.length = vec.ct.len;
 486                 sym->auth.digest.data = vec.cipher_auth.digest.val;
 487                 sym->auth.digest.phys_addr = rte_malloc_virt2iova(
 488                                 sym->auth.digest.data);
 489         }
 490
 491         rte_crypto_op_attach_sym_session(env.op, env.sess);
 492
 493         return 0;
 494 }
 495
 496 static int
 497 prepare_aead_op(void)
 498 {
 499         struct rte_crypto_sym_op *sym = env.op->sym;
 500         uint8_t *iv = rte_crypto_op_ctod_offset(env.op, uint8_t *, IV_OFF);
 501
 502         __rte_crypto_op_reset(env.op, RTE_CRYPTO_OP_TYPE_SYMMETRIC);
 503         rte_pktmbuf_reset(env.mbuf);
 504
 505         if (info.algo == FIPS_TEST_ALGO_AES_CCM)
 506                 memcpy(iv + 1, vec.iv.val, vec.iv.len);
 507         else
 508                 memcpy(iv, vec.iv.val, vec.iv.len);
 509
 510         sym->m_src = env.mbuf;
 511         sym->aead.data.offset = 0;
 512         sym->aead.aad.data = vec.aead.aad.val;
 513         sym->aead.aad.phys_addr = rte_malloc_virt2iova(sym->aead.aad.data);
 514
 515         if (info.op == FIPS_TEST_ENC_AUTH_GEN) {
 516                 uint8_t *pt;
 517
 518                 if (vec.pt.len > RTE_MBUF_MAX_NB_SEGS) {
 519                         RTE_LOG(ERR, USER1, "PT len %u\n", vec.pt.len);
 520                         return -EPERM;
 521                 }
 522
 523                 pt = (uint8_t *)rte_pktmbuf_append(env.mbuf,
 524                                 vec.pt.len + vec.aead.digest.len);
 525
 526                 if (!pt) {
 527                         RTE_LOG(ERR, USER1, "Error %i: MBUF too small\n",
 528                                         -ENOMEM);
 529                         return -ENOMEM;
 530                 }
 531
 532                 memcpy(pt, vec.pt.val, vec.pt.len);
 533                 sym->aead.data.length = vec.pt.len;
 534                 sym->aead.digest.data = pt + vec.pt.len;
 535                 sym->aead.digest.phys_addr = rte_pktmbuf_mtophys_offset(
 536                                 env.mbuf, vec.pt.len);
 537         } else {
 538                 uint8_t *ct;
 539
 540                 if (vec.ct.len > RTE_MBUF_MAX_NB_SEGS) {
 541                         RTE_LOG(ERR, USER1, "CT len %u\n", vec.ct.len);
 542                         return -EPERM;
 543                 }
 544
 545                 ct = (uint8_t *)rte_pktmbuf_append(env.mbuf, vec.ct.len);
 546
 547                 if (!ct) {
 548                         RTE_LOG(ERR, USER1, "Error %i: MBUF too small\n",
 549                                         -ENOMEM);
 550                         return -ENOMEM;
 551                 }
 552
 553                 memcpy(ct, vec.ct.val, vec.ct.len);
 554                 sym->aead.data.length = vec.ct.len;
 555                 sym->aead.digest.data = vec.aead.digest.val;
 556                 sym->aead.digest.phys_addr = rte_malloc_virt2iova(
 557                                 sym->aead.digest.data);
 558         }
 559
 560         rte_crypto_op_attach_sym_session(env.op, env.sess);
 561
 562         return 0;
 563 }
 564
 565 static int
 566 prepare_aes_xform(struct rte_crypto_sym_xform *xform)
 567 {
 568         const struct rte_cryptodev_symmetric_capability *cap;
 569         struct rte_cryptodev_sym_capability_idx cap_idx;
 570         struct rte_crypto_cipher_xform *cipher_xform = &xform->cipher;
 571
 572         xform->type = RTE_CRYPTO_SYM_XFORM_CIPHER;
 573
 574         cipher_xform->algo = RTE_CRYPTO_CIPHER_AES_CBC;
 575         cipher_xform->op = (info.op == FIPS_TEST_ENC_AUTH_GEN) ?
 576                         RTE_CRYPTO_CIPHER_OP_ENCRYPT :
 577                         RTE_CRYPTO_CIPHER_OP_DECRYPT;
 578         cipher_xform->key.data = vec.cipher_auth.key.val;
 579         cipher_xform->key.length = vec.cipher_auth.key.len;
 580         cipher_xform->iv.length = vec.iv.len;
 581         cipher_xform->iv.offset = IV_OFF;
 582
 583         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
 584         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
 585
 586         cap = rte_cryptodev_sym_capability_get(env.dev_id, &cap_idx);
 587         if (!cap) {
 588                 RTE_LOG(ERR, USER1, "Failed to get capability for cdev %u\n",
 589                                 env.dev_id);
 590                 return -EINVAL;
 591         }
 592
 593         if (rte_cryptodev_sym_capability_check_cipher(cap,
 594                         cipher_xform->key.length,
 595                         cipher_xform->iv.length) != 0) {
 596                 RTE_LOG(ERR, USER1, "PMD %s key length %u IV length %u\n",
 597                                 info.device_name, cipher_xform->key.length,
 598                                 cipher_xform->iv.length);
 599                 return -EPERM;
 600         }
 601
 602         return 0;
 603 }
 604
 605 static int
 606 prepare_tdes_xform(struct rte_crypto_sym_xform *xform)
 607 {
 608         const struct rte_cryptodev_symmetric_capability *cap;
 609         struct rte_cryptodev_sym_capability_idx cap_idx;
 610         struct rte_crypto_cipher_xform *cipher_xform = &xform->cipher;
 611
 612         xform->type = RTE_CRYPTO_SYM_XFORM_CIPHER;
 613
 614         cipher_xform->algo = RTE_CRYPTO_CIPHER_3DES_CBC;
 615         cipher_xform->op = (info.op == FIPS_TEST_ENC_AUTH_GEN) ?
 616                         RTE_CRYPTO_CIPHER_OP_ENCRYPT :
 617                         RTE_CRYPTO_CIPHER_OP_DECRYPT;
 618         cipher_xform->key.data = vec.cipher_auth.key.val;
 619         cipher_xform->key.length = vec.cipher_auth.key.len;
 620         cipher_xform->iv.length = vec.iv.len;
 621         cipher_xform->iv.offset = IV_OFF;
 622
 623         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_3DES_CBC;
 624         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
 625
 626         cap = rte_cryptodev_sym_capability_get(env.dev_id, &cap_idx);
 627         if (!cap) {
 628                 RTE_LOG(ERR, USER1, "Failed to get capability for cdev %u\n",
 629                                 env.dev_id);
 630                 return -EINVAL;
 631         }
 632
 633         if (rte_cryptodev_sym_capability_check_cipher(cap,
 634                         cipher_xform->key.length,
 635                         cipher_xform->iv.length) != 0) {
 636                 RTE_LOG(ERR, USER1, "PMD %s key length %u IV length %u\n",
 637                                 info.device_name, cipher_xform->key.length,
 638                                 cipher_xform->iv.length);
 639                 return -EPERM;
 640         }
 641
 642         return 0;
 643 }
 644
 645 static int
 646 prepare_hmac_xform(struct rte_crypto_sym_xform *xform)
 647 {
 648         const struct rte_cryptodev_symmetric_capability *cap;
 649         struct rte_cryptodev_sym_capability_idx cap_idx;
 650         struct rte_crypto_auth_xform *auth_xform = &xform->auth;
 651
 652         xform->type = RTE_CRYPTO_SYM_XFORM_AUTH;
 653
 654         auth_xform->algo = info.interim_info.hmac_data.algo;
 655         auth_xform->op = RTE_CRYPTO_AUTH_OP_GENERATE;
 656         auth_xform->digest_length = vec.cipher_auth.digest.len;
 657         auth_xform->key.data = vec.cipher_auth.key.val;
 658         auth_xform->key.length = vec.cipher_auth.key.len;
 659
 660         cap_idx.algo.auth = auth_xform->algo;
 661         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
 662
 663         cap = rte_cryptodev_sym_capability_get(env.dev_id, &cap_idx);
 664         if (!cap) {
 665                 RTE_LOG(ERR, USER1, "Failed to get capability for cdev %u\n",
 666                                 env.dev_id);
 667                 return -EINVAL;
 668         }
 669
 670         if (rte_cryptodev_sym_capability_check_auth(cap,
 671                         auth_xform->key.length,
 672                         auth_xform->digest_length, 0) != 0) {
 673                 RTE_LOG(ERR, USER1, "PMD %s key length %u IV length %u\n",
 674                                 info.device_name, auth_xform->key.length,
 675                                 auth_xform->digest_length);
 676                 return -EPERM;
 677         }
 678
 679         return 0;
 680 }
 681
 682 static int
 683 prepare_gcm_xform(struct rte_crypto_sym_xform *xform)
 684 {
 685         const struct rte_cryptodev_symmetric_capability *cap;
 686         struct rte_cryptodev_sym_capability_idx cap_idx;
 687         struct rte_crypto_aead_xform *aead_xform = &xform->aead;
 688
 689         xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
 690
 691         aead_xform->algo = RTE_CRYPTO_AEAD_AES_GCM;
 692         aead_xform->aad_length = vec.aead.aad.len;
 693         aead_xform->digest_length = vec.aead.digest.len;
 694         aead_xform->iv.offset = IV_OFF;
 695         aead_xform->iv.length = vec.iv.len;
 696         aead_xform->key.data = vec.aead.key.val;
 697         aead_xform->key.length = vec.aead.key.len;
 698         aead_xform->op = (info.op == FIPS_TEST_ENC_AUTH_GEN) ?
 699                         RTE_CRYPTO_AEAD_OP_ENCRYPT :
 700                         RTE_CRYPTO_AEAD_OP_DECRYPT;
 701
 702         cap_idx.algo.aead = aead_xform->algo;
 703         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
 704
 705         cap = rte_cryptodev_sym_capability_get(env.dev_id, &cap_idx);
 706         if (!cap) {
 707                 RTE_LOG(ERR, USER1, "Failed to get capability for cdev %u\n",
 708                                 env.dev_id);
 709                 return -EINVAL;
 710         }
 711
 712         if (rte_cryptodev_sym_capability_check_aead(cap,
 713                         aead_xform->key.length,
 714                         aead_xform->digest_length, aead_xform->aad_length,
 715                         aead_xform->iv.length) != 0) {
 716                 RTE_LOG(ERR, USER1,
 717                         "PMD %s key_len %u tag_len %u aad_len %u iv_len %u\n",
 718                                 info.device_name, aead_xform->key.length,
 719                                 aead_xform->digest_length,
 720                                 aead_xform->aad_length,
 721                                 aead_xform->iv.length);
 722                 return -EPERM;
 723         }
 724
 725         return 0;
 726 }
 727
 728 static int
 729 prepare_cmac_xform(struct rte_crypto_sym_xform *xform)
 730 {
 731         const struct rte_cryptodev_symmetric_capability *cap;
 732         struct rte_cryptodev_sym_capability_idx cap_idx;
 733         struct rte_crypto_auth_xform *auth_xform = &xform->auth;
 734
 735         xform->type = RTE_CRYPTO_SYM_XFORM_AUTH;
 736
 737         auth_xform->algo = RTE_CRYPTO_AUTH_AES_CMAC;
 738         auth_xform->op = (info.op == FIPS_TEST_ENC_AUTH_GEN) ?
 739                         RTE_CRYPTO_AUTH_OP_GENERATE : RTE_CRYPTO_AUTH_OP_VERIFY;
 740         auth_xform->digest_length = vec.cipher_auth.digest.len;
 741         auth_xform->key.data = vec.cipher_auth.key.val;
 742         auth_xform->key.length = vec.cipher_auth.key.len;
 743
 744         cap_idx.algo.auth = auth_xform->algo;
 745         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
 746
 747         cap = rte_cryptodev_sym_capability_get(env.dev_id, &cap_idx);
 748         if (!cap) {
 749                 RTE_LOG(ERR, USER1, "Failed to get capability for cdev %u\n",
 750                                 env.dev_id);
 751                 return -EINVAL;
 752         }
 753
 754         if (rte_cryptodev_sym_capability_check_auth(cap,
 755                         auth_xform->key.length,
 756                         auth_xform->digest_length, 0) != 0) {
 757                 RTE_LOG(ERR, USER1, "PMD %s key length %u IV length %u\n",
 758                                 info.device_name, auth_xform->key.length,
 759                                 auth_xform->digest_length);
 760                 return -EPERM;
 761         }
 762
 763         return 0;
 764 }
 765
 766 static int
 767 prepare_ccm_xform(struct rte_crypto_sym_xform *xform)
 768 {
 769         const struct rte_cryptodev_symmetric_capability *cap;
 770         struct rte_cryptodev_sym_capability_idx cap_idx;
 771         struct rte_crypto_aead_xform *aead_xform = &xform->aead;
 772
 773         xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
 774
 775         aead_xform->algo = RTE_CRYPTO_AEAD_AES_CCM;
 776         aead_xform->aad_length = vec.aead.aad.len;
 777         aead_xform->digest_length = vec.aead.digest.len;
 778         aead_xform->iv.offset = IV_OFF;
 779         aead_xform->iv.length = vec.iv.len;
 780         aead_xform->key.data = vec.aead.key.val;
 781         aead_xform->key.length = vec.aead.key.len;
 782         aead_xform->op = (info.op == FIPS_TEST_ENC_AUTH_GEN) ?
 783                         RTE_CRYPTO_AEAD_OP_ENCRYPT :
 784                         RTE_CRYPTO_AEAD_OP_DECRYPT;
 785
 786         cap_idx.algo.aead = aead_xform->algo;
 787         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
 788
 789         cap = rte_cryptodev_sym_capability_get(env.dev_id, &cap_idx);
 790         if (!cap) {
 791                 RTE_LOG(ERR, USER1, "Failed to get capability for cdev %u\n",
 792                                 env.dev_id);
 793                 return -EINVAL;
 794         }
 795
 796         if (rte_cryptodev_sym_capability_check_aead(cap,
 797                         aead_xform->key.length,
 798                         aead_xform->digest_length, aead_xform->aad_length,
 799                         aead_xform->iv.length) != 0) {
 800                 RTE_LOG(ERR, USER1,
 801                         "PMD %s key_len %u tag_len %u aad_len %u iv_len %u\n",
 802                                 info.device_name, aead_xform->key.length,
 803                                 aead_xform->digest_length,
 804                                 aead_xform->aad_length,
 805                                 aead_xform->iv.length);
 806                 return -EPERM;
 807         }
 808
 809         return 0;
 810 }
 811
 812 static void
 813 get_writeback_data(struct fips_val *val)
 814 {
 815         val->val = rte_pktmbuf_mtod(env.mbuf, uint8_t *);
 816         val->len = rte_pktmbuf_pkt_len(env.mbuf);
 817 }
 818
 819 static int
 820 fips_run_test(void)
 821 {
 822         struct rte_crypto_sym_xform xform = {0};
 823         uint16_t n_deqd;
 824         int ret;
 825
 826         ret = test_ops.prepare_xform(&xform);
 827         if (ret < 0)
 828                 return ret;
 829
 830         env.sess = rte_cryptodev_sym_session_create(env.sess_mpool);
 831         if (!env.sess)
 832                 return -ENOMEM;
 833
 834         ret = rte_cryptodev_sym_session_init(env.dev_id,
 835                         env.sess, &xform, env.sess_priv_mpool);
 836         if (ret < 0) {
 837                 RTE_LOG(ERR, USER1, "Error %i: Init session\n",
 838                                 ret);
 839                 return ret;
 840         }
 841
 842         ret = test_ops.prepare_op();
 843         if (ret < 0) {
 844                 RTE_LOG(ERR, USER1, "Error %i: Prepare op\n",
 845                                 ret);
 846                 return ret;
 847         }
 848
 849         if (rte_cryptodev_enqueue_burst(env.dev_id, 0, &env.op, 1) < 1) {
 850                 RTE_LOG(ERR, USER1, "Error: Failed enqueue\n");
 851                 return ret;
 852         }
 853
 854         do {
 855                 struct rte_crypto_op *deqd_op;
 856
 857                 n_deqd = rte_cryptodev_dequeue_burst(env.dev_id, 0, &deqd_op,
 858                                 1);
 859         } while (n_deqd == 0);
 860
 861         vec.status = env.op->status;
 862
 863         rte_cryptodev_sym_session_clear(env.dev_id, env.sess);
 864         rte_cryptodev_sym_session_free(env.sess);
 865         env.sess = NULL;
 866
 867         return ret;
 868 }
 869
 870 static int
 871 fips_generic_test(void)
 872 {
 873         struct fips_val val;
 874         int ret;
 875
 876         fips_test_write_one_case();
 877
 878         ret = fips_run_test();
 879         if (ret < 0) {
 880                 if (ret == -EPERM) {
 881                         fprintf(info.fp_wr, "Bypass\n\n");
 882                         return 0;
 883                 }
 884
 885                 return ret;
 886         }
 887
 888         get_writeback_data(&val);
 889
 890         switch (info.file_type) {
 891         case FIPS_TYPE_REQ:
 892         case FIPS_TYPE_RSP:
 893                 if (info.parse_writeback == NULL)
 894                         return -EPERM;
 895                 ret = info.parse_writeback(&val);
 896                 if (ret < 0)
 897                         return ret;
 898                 break;
 899         case FIPS_TYPE_FAX:
 900                 if (info.kat_check == NULL)
 901                         return -EPERM;
 902                 ret = info.kat_check(&val);
 903                 if (ret < 0)
 904                         return ret;
 905                 break;
 906         }
 907
 908         fprintf(info.fp_wr, "\n");
 909
 910         return 0;
 911 }
 912
 913 static int
 914 fips_mct_tdes_test(void)
 915 {
 916 #define TDES_BLOCK_SIZE         8
 917 #define TDES_EXTERN_ITER        400
 918 #define TDES_INTERN_ITER        10000
 919         struct fips_val val, val_key;
 920         uint8_t prev_out[TDES_BLOCK_SIZE] = {0};
 921         uint8_t prev_prev_out[TDES_BLOCK_SIZE] = {0};
 922         uint8_t prev_in[TDES_BLOCK_SIZE] = {0};
 923         uint32_t i, j, k;
 924         int ret;
 925
 926         for (i = 0; i < TDES_EXTERN_ITER; i++) {
 927                 if (i != 0)
 928                         update_info_vec(i);
 929
 930                 fips_test_write_one_case();
 931
 932                 for (j = 0; j < TDES_INTERN_ITER; j++) {
 933                         ret = fips_run_test();
 934                         if (ret < 0) {
 935                                 if (ret == -EPERM) {
 936                                         fprintf(info.fp_wr, "Bypass\n");
 937                                         return 0;
 938                                 }
 939
 940                                 return ret;
 941                         }
 942
 943                         get_writeback_data(&val);
 944
 945                         if (info.op == FIPS_TEST_DEC_AUTH_VERIF)
 946                                 memcpy(prev_in, vec.ct.val, TDES_BLOCK_SIZE);
 947
 948                         if (j == 0) {
 949                                 memcpy(prev_out, val.val, TDES_BLOCK_SIZE);
 950
 951                                 if (info.op == FIPS_TEST_ENC_AUTH_GEN) {
 952                                         memcpy(vec.pt.val, vec.iv.val,
 953                                                         TDES_BLOCK_SIZE);
 954                                         memcpy(vec.iv.val, val.val,
 955                                                         TDES_BLOCK_SIZE);
 956                                 } else {
 957                                         memcpy(vec.iv.val, vec.ct.val,
 958                                                         TDES_BLOCK_SIZE);
 959                                         memcpy(vec.ct.val, val.val,
 960                                                         TDES_BLOCK_SIZE);
 961                                 }
 962                                 continue;
 963                         }
 964
 965                         if (info.op == FIPS_TEST_ENC_AUTH_GEN) {
 966                                 memcpy(vec.iv.val, val.val, TDES_BLOCK_SIZE);
 967                                 memcpy(vec.pt.val, prev_out, TDES_BLOCK_SIZE);
 968                         } else {
 969                                 memcpy(vec.iv.val, vec.ct.val, TDES_BLOCK_SIZE);
 970                                 memcpy(vec.ct.val, val.val, TDES_BLOCK_SIZE);
 971                         }
 972
 973                         if (j == TDES_INTERN_ITER - 1)
 974                                 continue;
 975
 976                         memcpy(prev_out, val.val, TDES_BLOCK_SIZE);
 977
 978                         if (j == TDES_INTERN_ITER - 3)
 979                                 memcpy(prev_prev_out, val.val, TDES_BLOCK_SIZE);
 980                 }
 981
 982                 info.parse_writeback(&val);
 983                 fprintf(info.fp_wr, "\n");
 984
 985                 if (i == TDES_EXTERN_ITER - 1)
 986                         continue;
 987
 988                 /** update key */
 989                 memcpy(&val_key, &vec.cipher_auth.key, sizeof(val_key));
 990
 991                 if (info.interim_info.tdes_data.nb_keys == 0) {
 992                         if (memcmp(val_key.val, val_key.val + 8, 8) == 0)
 993                                 info.interim_info.tdes_data.nb_keys = 1;
 994                         else if (memcmp(val_key.val, val_key.val + 16, 8) == 0)
 995                                 info.interim_info.tdes_data.nb_keys = 2;
 996                         else
 997                                 info.interim_info.tdes_data.nb_keys = 3;
 998
 999                 }
1000
1001                 for (k = 0; k < TDES_BLOCK_SIZE; k++) {
1002
1003                         switch (info.interim_info.tdes_data.nb_keys) {
1004                         case 3:
1005                                 val_key.val[k] ^= val.val[k];
1006                                 val_key.val[k + 8] ^= prev_out[k];
1007                                 val_key.val[k + 16] ^= prev_prev_out[k];
1008                                 break;
1009                         case 2:
1010                                 val_key.val[k] ^= val.val[k];
1011                                 val_key.val[k + 8] ^= prev_out[k];
1012                                 val_key.val[k + 16] ^= val.val[k];
1013                                 break;
1014                         default: /* case 1 */
1015                                 val_key.val[k] ^= val.val[k];
1016                                 val_key.val[k + 8] ^= val.val[k];
1017                                 val_key.val[k + 16] ^= val.val[k];
1018                                 break;
1019                         }
1020
1021                 }
1022
1023                 for (k = 0; k < 24; k++)
1024                         val_key.val[k] = (__builtin_popcount(val_key.val[k]) &
1025                                         0x1) ?
1026                                         val_key.val[k] : (val_key.val[k] ^ 0x1);
1027
1028                 if (info.op == FIPS_TEST_ENC_AUTH_GEN) {
1029                         memcpy(vec.iv.val, val.val, TDES_BLOCK_SIZE);
1030                         memcpy(vec.pt.val, prev_out, TDES_BLOCK_SIZE);
1031                 } else {
1032                         memcpy(vec.iv.val, prev_out, TDES_BLOCK_SIZE);
1033                         memcpy(vec.ct.val, val.val, TDES_BLOCK_SIZE);
1034                 }
1035         }
1036
1037         return 0;
1038 }
1039
1040 static int
1041 fips_mct_aes_test(void)
1042 {
1043 #define AES_BLOCK_SIZE  16
1044 #define AES_EXTERN_ITER 100
1045 #define AES_INTERN_ITER 1000
1046         struct fips_val val, val_key;
1047         uint8_t prev_out[AES_BLOCK_SIZE] = {0};
1048         uint8_t prev_in[AES_BLOCK_SIZE] = {0};
1049         uint32_t i, j, k;
1050         int ret;
1051
1052         for (i = 0; i < AES_EXTERN_ITER; i++) {
1053                 if (i != 0)
1054                         update_info_vec(i);
1055
1056                 fips_test_write_one_case();
1057
1058                 for (j = 0; j < AES_INTERN_ITER; j++) {
1059                         ret = fips_run_test();
1060                         if (ret < 0) {
1061                                 if (ret == -EPERM) {
1062                                         fprintf(info.fp_wr, "Bypass\n");
1063                                         return 0;
1064                                 }
1065
1066                                 return ret;
1067                         }
1068
1069                         get_writeback_data(&val);
1070
1071                         if (info.op == FIPS_TEST_DEC_AUTH_VERIF)
1072                                 memcpy(prev_in, vec.ct.val, AES_BLOCK_SIZE);
1073
1074                         if (j == 0) {
1075                                 memcpy(prev_out, val.val, AES_BLOCK_SIZE);
1076
1077                                 if (info.op == FIPS_TEST_ENC_AUTH_GEN) {
1078                                         memcpy(vec.pt.val, vec.iv.val,
1079                                                         AES_BLOCK_SIZE);
1080                                         memcpy(vec.iv.val, val.val,
1081                                                         AES_BLOCK_SIZE);
1082                                 } else {
1083                                         memcpy(vec.ct.val, vec.iv.val,
1084                                                         AES_BLOCK_SIZE);
1085                                         memcpy(vec.iv.val, prev_in,
1086                                                         AES_BLOCK_SIZE);
1087                                 }
1088                                 continue;
1089                         }
1090
1091                         if (info.op == FIPS_TEST_ENC_AUTH_GEN) {
1092                                 memcpy(vec.iv.val, val.val, AES_BLOCK_SIZE);
1093                                 memcpy(vec.pt.val, prev_out, AES_BLOCK_SIZE);
1094                         } else {
1095                                 memcpy(vec.iv.val, prev_in, AES_BLOCK_SIZE);
1096                                 memcpy(vec.ct.val, prev_out, AES_BLOCK_SIZE);
1097                         }
1098
1099                         if (j == AES_INTERN_ITER - 1)
1100                                 continue;
1101
1102                         memcpy(prev_out, val.val, AES_BLOCK_SIZE);
1103                 }
1104
1105                 info.parse_writeback(&val);
1106                 fprintf(info.fp_wr, "\n");
1107
1108                 if (i == AES_EXTERN_ITER - 1)
1109                         continue;
1110
1111                 /** update key */
1112                 memcpy(&val_key, &vec.cipher_auth.key, sizeof(val_key));
1113                 for (k = 0; k < vec.cipher_auth.key.len; k++) {
1114                         switch (vec.cipher_auth.key.len) {
1115                         case 16:
1116                                 val_key.val[k] ^= val.val[k];
1117                                 break;
1118                         case 24:
1119                                 if (k < 8)
1120                                         val_key.val[k] ^= prev_out[k + 8];
1121                                 else
1122                                         val_key.val[k] ^= val.val[k - 8];
1123                                 break;
1124                         case 32:
1125                                 if (k < 16)
1126                                         val_key.val[k] ^= prev_out[k];
1127                                 else
1128                                         val_key.val[k] ^= val.val[k - 16];
1129                                 break;
1130                         default:
1131                                 return -1;
1132                         }
1133                 }
1134
1135                 if (info.op == FIPS_TEST_DEC_AUTH_VERIF)
1136                         memcpy(vec.iv.val, val.val, AES_BLOCK_SIZE);
1137         }
1138
1139         return 0;
1140 }
1141
1142 static int
1143 init_test_ops(void)
1144 {
1145         switch (info.algo) {
1146         case FIPS_TEST_ALGO_AES:
1147                 test_ops.prepare_op = prepare_cipher_op;
1148                 test_ops.prepare_xform  = prepare_aes_xform;
1149                 if (info.interim_info.aes_data.test_type == AESAVS_TYPE_MCT)
1150                         test_ops.test = fips_mct_aes_test;
1151                 else
1152                         test_ops.test = fips_generic_test;
1153                 break;
1154         case FIPS_TEST_ALGO_HMAC:
1155                 test_ops.prepare_op = prepare_auth_op;
1156                 test_ops.prepare_xform = prepare_hmac_xform;
1157                 test_ops.test = fips_generic_test;
1158                 break;
1159         case FIPS_TEST_ALGO_TDES:
1160                 test_ops.prepare_op = prepare_cipher_op;
1161                 test_ops.prepare_xform  = prepare_tdes_xform;
1162                 if (info.interim_info.tdes_data.test_type == TDES_MCT)
1163                         test_ops.test = fips_mct_tdes_test;
1164                 else
1165                         test_ops.test = fips_generic_test;
1166                 break;
1167         case FIPS_TEST_ALGO_AES_GCM:
1168                 test_ops.prepare_op = prepare_aead_op;
1169                 test_ops.prepare_xform = prepare_gcm_xform;
1170                 test_ops.test = fips_generic_test;
1171                 break;
1172         case FIPS_TEST_ALGO_AES_CMAC:
1173                 test_ops.prepare_op = prepare_auth_op;
1174                 test_ops.prepare_xform = prepare_cmac_xform;
1175                 test_ops.test = fips_generic_test;
1176                 break;
1177         case FIPS_TEST_ALGO_AES_CCM:
1178                 test_ops.prepare_op = prepare_aead_op;
1179                 test_ops.prepare_xform = prepare_ccm_xform;
1180                 test_ops.test = fips_generic_test;
1181                 break;
1182         default:
1183                 return -1;
1184         }
1185
1186         return 0;
1187 }
1188
1189 static void
1190 print_test_block(void)
1191 {
1192         uint32_t i;
1193
1194         for (i = 0; i < info.nb_vec_lines; i++)
1195                 printf("%s\n", info.vec[i]);
1196
1197         printf("\n");
1198 }
1199
1200 static int
1201 fips_test_one_file(void)
1202 {
1203         int fetch_ret = 0, ret;
1204
1205
1206         ret = init_test_ops();
1207         if (ret < 0) {
1208                 RTE_LOG(ERR, USER1, "Error %i: Init test op\n", ret);
1209                 return ret;
1210         }
1211
1212         while (ret >= 0 && fetch_ret == 0) {
1213                 fetch_ret = fips_test_fetch_one_block();
1214                 if (fetch_ret < 0) {
1215                         RTE_LOG(ERR, USER1, "Error %i: Fetch block\n",
1216                                         fetch_ret);
1217                         ret = fetch_ret;
1218                         goto error_one_case;
1219                 }
1220
1221                 if (info.nb_vec_lines == 0) {
1222                         if (fetch_ret == -EOF)
1223                                 break;
1224
1225                         fprintf(info.fp_wr, "\n");
1226                         continue;
1227                 }
1228
1229                 ret = fips_test_parse_one_case();
1230                 switch (ret) {
1231                 case 0:
1232                         ret = test_ops.test();
1233                         if (ret == 0)
1234                                 break;
1235                         RTE_LOG(ERR, USER1, "Error %i: test block\n",
1236                                         ret);
1237                         goto error_one_case;
1238                 case 1:
1239                         break;
1240                 default:
1241                         RTE_LOG(ERR, USER1, "Error %i: Parse block\n",
1242                                         ret);
1243                         goto error_one_case;
1244                 }
1245
1246                 continue;
1247 error_one_case:
1248                 print_test_block();
1249         }
1250
1251         fips_test_clear();
1252
1253         return ret;
1254
1255 }