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 *op_pool;
  33         struct rte_mbuf *mbuf;
  34         struct rte_crypto_op *op;
  35         struct rte_cryptodev_sym_session *sess;
  36 } env;
  37
  38 static int
  39 cryptodev_fips_validate_app_int(void)
  40 {
  41         struct rte_cryptodev_config conf = {rte_socket_id(), 1};
  42         struct rte_cryptodev_qp_conf qp_conf = {128};
  43         int ret;
  44
  45         ret = rte_cryptodev_configure(env.dev_id, &conf);
  46         if (ret < 0)
  47                 return ret;
  48
  49         env.mpool = rte_pktmbuf_pool_create("FIPS_MEMPOOL", 128, 0, 0,
  50                         UINT16_MAX, rte_socket_id());
  51         if (!env.mpool)
  52                 return ret;
  53
  54         ret = rte_cryptodev_queue_pair_setup(env.dev_id, 0, &qp_conf,
  55                         rte_socket_id(), env.mpool);
  56         if (ret < 0)
  57                 return ret;
  58
  59         ret = -ENOMEM;
  60
  61         env.op_pool = rte_crypto_op_pool_create(
  62                         "FIPS_OP_POOL",
  63                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
  64                         1, 0,
  65                         16,
  66                         rte_socket_id());
  67         if (!env.op_pool)
  68                 goto error_exit;
  69
  70         env.mbuf = rte_pktmbuf_alloc(env.mpool);
  71         if (!env.mbuf)
  72                 goto error_exit;
  73
  74         env.op = rte_crypto_op_alloc(env.op_pool, RTE_CRYPTO_OP_TYPE_SYMMETRIC);
  75         if (!env.op)
  76                 goto error_exit;
  77
  78         return 0;
  79
  80 error_exit:
  81         rte_mempool_free(env.mpool);
  82         if (env.op_pool)
  83                 rte_mempool_free(env.op_pool);
  84
  85         return ret;
  86 }
  87
  88 static void
  89 cryptodev_fips_validate_app_uninit(void)
  90 {
  91         rte_pktmbuf_free(env.mbuf);
  92         rte_crypto_op_free(env.op);
  93         rte_cryptodev_sym_session_clear(env.dev_id, env.sess);
  94         rte_cryptodev_sym_session_free(env.sess);
  95         rte_mempool_free(env.mpool);
  96         rte_mempool_free(env.op_pool);
  97 }
  98
  99 static int
 100 fips_test_one_file(void);
 101
 102 static int
 103 parse_cryptodev_arg(char *arg)
 104 {
 105         int id = rte_cryptodev_get_dev_id(arg);
 106
 107         if (id < 0) {
 108                 RTE_LOG(ERR, USER1, "Error %i: invalid cryptodev name %s\n",
 109                                 id, arg);
 110                 return id;
 111         }
 112
 113         env.dev_id = (uint32_t)id;
 114
 115         return 0;
 116 }
 117
 118 static int
 119 parse_cryptodev_id_arg(char *arg)
 120 {
 121         uint32_t cryptodev_id;
 122
 123         if (parser_read_uint32(&cryptodev_id, arg) < 0) {
 124                 RTE_LOG(ERR, USER1, "Error %i: invalid cryptodev id %s\n",
 125                                 -EINVAL, arg);
 126                 return -1;
 127         }
 128
 129
 130         if (!rte_cryptodev_pmd_is_valid_dev(cryptodev_id)) {
 131                 RTE_LOG(ERR, USER1, "Error %i: invalid cryptodev id %s\n",
 132                                 cryptodev_id, arg);
 133                 return -1;
 134         }
 135
 136         env.dev_id = (uint32_t)cryptodev_id;
 137
 138         return 0;
 139 }
 140
 141 static void
 142 cryptodev_fips_validate_usage(const char *prgname)
 143 {
 144         printf("%s [EAL options] --\n"
 145                 "  --%s: REQUEST-FILE-PATH\n"
 146                 "  --%s: RESPONSE-FILE-PATH\n"
 147                 "  --%s: indicating both paths are folders\n"
 148                 "  --%s: CRYPTODEV-NAME\n"
 149                 "  --%s: CRYPTODEV-ID-NAME\n",
 150                 prgname, REQ_FILE_PATH_KEYWORD, RSP_FILE_PATH_KEYWORD,
 151                 FOLDER_KEYWORD, CRYPTODEV_KEYWORD, CRYPTODEV_ID_KEYWORD);
 152 }
 153
 154 static int
 155 cryptodev_fips_validate_parse_args(int argc, char **argv)
 156 {
 157         int opt, ret;
 158         char *prgname = argv[0];
 159         char **argvopt;
 160         int option_index;
 161         struct option lgopts[] = {
 162                         {REQ_FILE_PATH_KEYWORD, required_argument, 0, 0},
 163                         {RSP_FILE_PATH_KEYWORD, required_argument, 0, 0},
 164                         {FOLDER_KEYWORD, no_argument, 0, 0},
 165                         {CRYPTODEV_KEYWORD, required_argument, 0, 0},
 166                         {CRYPTODEV_ID_KEYWORD, required_argument, 0, 0},
 167                         {NULL, 0, 0, 0}
 168         };
 169
 170         argvopt = argv;
 171
 172         while ((opt = getopt_long(argc, argvopt, "s:",
 173                                   lgopts, &option_index)) != EOF) {
 174
 175                 switch (opt) {
 176                 case 0:
 177                         if (strcmp(lgopts[option_index].name,
 178                                         REQ_FILE_PATH_KEYWORD) == 0)
 179                                 env.req_path = optarg;
 180                         else if (strcmp(lgopts[option_index].name,
 181                                         RSP_FILE_PATH_KEYWORD) == 0)
 182                                 env.rsp_path = optarg;
 183                         else if (strcmp(lgopts[option_index].name,
 184                                         FOLDER_KEYWORD) == 0)
 185                                 env.is_path_folder = 1;
 186                         else if (strcmp(lgopts[option_index].name,
 187                                         CRYPTODEV_KEYWORD) == 0) {
 188                                 ret = parse_cryptodev_arg(optarg);
 189                                 if (ret < 0) {
 190                                         cryptodev_fips_validate_usage(prgname);
 191                                         return -EINVAL;
 192                                 }
 193                         } else if (strcmp(lgopts[option_index].name,
 194                                         CRYPTODEV_ID_KEYWORD) == 0) {
 195                                 ret = parse_cryptodev_id_arg(optarg);
 196                                 if (ret < 0) {
 197                                         cryptodev_fips_validate_usage(prgname);
 198                                         return -EINVAL;
 199                                 }
 200                         } else {
 201                                 cryptodev_fips_validate_usage(prgname);
 202                                 return -EINVAL;
 203                         }
 204                         break;
 205                 default:
 206                         return -1;
 207                 }
 208         }
 209
 210         if (env.req_path == NULL || env.rsp_path == NULL ||
 211                         env.dev_id == UINT32_MAX) {
 212                 cryptodev_fips_validate_usage(prgname);
 213                 return -EINVAL;
 214         }
 215
 216         return 0;
 217 }
 218
 219 int
 220 main(int argc, char *argv[])
 221 {
 222         int ret;
 223
 224         ret = rte_eal_init(argc, argv);
 225         if (ret < 0) {
 226                 RTE_LOG(ERR, USER1, "Error %i: Failed init\n", ret);
 227                 return -1;
 228         }
 229
 230         argc -= ret;
 231         argv += ret;
 232
 233         ret = cryptodev_fips_validate_parse_args(argc, argv);
 234         if (ret < 0)
 235                 rte_exit(EXIT_FAILURE, "Failed to parse arguments!\n");
 236
 237         ret = cryptodev_fips_validate_app_int();
 238         if (ret < 0) {
 239                 RTE_LOG(ERR, USER1, "Error %i: Failed init\n", ret);
 240                 return -1;
 241         }
 242
 243         if (!env.is_path_folder) {
 244                 printf("Processing file %s... ", env.req_path);
 245
 246                 ret = fips_test_init(env.req_path, env.rsp_path,
 247                         rte_cryptodev_name_get(env.dev_id));
 248                 if (ret < 0) {
 249                         RTE_LOG(ERR, USER1, "Error %i: Failed test %s\n",
 250                                         ret, env.req_path);
 251                         goto exit;
 252                 }
 253
 254
 255                 ret = fips_test_one_file();
 256                 if (ret < 0) {
 257                         RTE_LOG(ERR, USER1, "Error %i: Failed test %s\n",
 258                                         ret, env.req_path);
 259                         goto exit;
 260                 }
 261
 262                 printf("Done\n");
 263
 264         } else {
 265                 struct dirent *dir;
 266                 DIR *d_req, *d_rsp;
 267                 char req_path[1024];
 268                 char rsp_path[1024];
 269
 270                 d_req = opendir(env.req_path);
 271                 if (!d_req) {
 272                         RTE_LOG(ERR, USER1, "Error %i: Path %s not exist\n",
 273                                         -EINVAL, env.req_path);
 274                         goto exit;
 275                 }
 276
 277                 d_rsp = opendir(env.rsp_path);
 278                 if (!d_rsp) {
 279                         ret = mkdir(env.rsp_path, 0700);
 280                         if (ret == 0)
 281                                 d_rsp = opendir(env.rsp_path);
 282                         else {
 283                                 RTE_LOG(ERR, USER1, "Error %i: Invalid %s\n",
 284                                                 -EINVAL, env.rsp_path);
 285                                 goto exit;
 286                         }
 287                 }
 288                 closedir(d_rsp);
 289
 290                 while ((dir = readdir(d_req)) != NULL) {
 291                         if (strstr(dir->d_name, "req") == NULL)
 292                                 continue;
 293
 294                         snprintf(req_path, 1023, "%s/%s", env.req_path,
 295                                         dir->d_name);
 296                         snprintf(rsp_path, 1023, "%s/%s", env.rsp_path,
 297                                         dir->d_name);
 298                         strlcpy(strstr(rsp_path, "req"), "rsp", 4);
 299
 300                         printf("Processing file %s... ", req_path);
 301
 302                         ret = fips_test_init(req_path, rsp_path,
 303                         rte_cryptodev_name_get(env.dev_id));
 304                         if (ret < 0) {
 305                                 RTE_LOG(ERR, USER1, "Error %i: Failed test %s\n",
 306                                                 ret, req_path);
 307                                 break;
 308                         }
 309
 310                         ret = fips_test_one_file();
 311                         if (ret < 0) {
 312                                 RTE_LOG(ERR, USER1, "Error %i: Failed test %s\n",
 313                                                 ret, req_path);
 314                                 break;
 315                         }
 316
 317                         printf("Done\n");
 318                 }
 319
 320                 closedir(d_req);
 321         }
 322
 323
 324 exit:
 325         fips_test_clear();
 326         cryptodev_fips_validate_app_uninit();
 327
 328         return ret;
 329
 330 }
 331
 332 static void
 333 print_test_block(void)
 334 {
 335         uint32_t i;
 336
 337         for (i = 0; i < info.nb_vec_lines; i++)
 338                 printf("%s\n", info.vec[i]);
 339
 340         printf("\n");
 341 }
 342
 343 static int
 344 fips_test_one_file(void)
 345 {
 346         int fetch_ret = 0, ret;
 347
 348         while (fetch_ret == 0) {
 349                 fetch_ret = fips_test_fetch_one_block();
 350                 if (fetch_ret < 0) {
 351                         RTE_LOG(ERR, USER1, "Error %i: Fetch block\n",
 352                                         fetch_ret);
 353                         ret = fetch_ret;
 354                         goto error_one_case;
 355                 }
 356
 357                 if (info.nb_vec_lines == 0) {
 358                         if (fetch_ret == -EOF)
 359                                 break;
 360
 361                         fprintf(info.fp_wr, "\n");
 362                         continue;
 363                 }
 364
 365                 ret = fips_test_parse_one_case();
 366                 switch (ret) {
 367                 case 0:
 368                         if (ret == 0)
 369                                 break;
 370                         RTE_LOG(ERR, USER1, "Error %i: test block\n",
 371                                         ret);
 372                         goto error_one_case;
 373                 case 1:
 374                         break;
 375                 default:
 376                         RTE_LOG(ERR, USER1, "Error %i: Parse block\n",
 377                                         ret);
 378                         goto error_one_case;
 379                 }
 380
 381                 continue;
 382 error_one_case:
 383                 print_test_block();
 384         }
 385
 386         fips_test_clear();
 387
 388 }