apps/fipsinstall.c

   1 /*
   2  * Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <string.h>
  11 #include <openssl/evp.h>
  12 #include <openssl/err.h>
  13 #include <openssl/provider.h>
  14 #include <openssl/params.h>
  15 #include <openssl/fips_names.h>
  16 #include <openssl/core_names.h>
  17 #include <openssl/self_test.h>
  18 #include <openssl/fipskey.h>
  19 #include "apps.h"
  20 #include "progs.h"
  21
  22 DEFINE_STACK_OF_STRING()
  23
  24 #define BUFSIZE 4096
  25
  26 /* Configuration file values */
  27 #define VERSION_KEY  "version"
  28 #define VERSION_VAL  "1"
  29 #define INSTALL_STATUS_VAL "INSTALL_SELF_TEST_KATS_RUN"
  30
  31 static OSSL_CALLBACK self_test_events;
  32 static char *self_test_corrupt_desc = NULL;
  33 static char *self_test_corrupt_type = NULL;
  34 static int self_test_log = 1;
  35 static int quiet = 0;
  36
  37 typedef enum OPTION_choice {
  38     OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
  39     OPT_IN, OPT_OUT, OPT_MODULE,
  40     OPT_PROV_NAME, OPT_SECTION_NAME, OPT_MAC_NAME, OPT_MACOPT, OPT_VERIFY,
  41     OPT_NO_LOG, OPT_CORRUPT_DESC, OPT_CORRUPT_TYPE, OPT_QUIET, OPT_CONFIG
  42 } OPTION_CHOICE;
  43
  44 const OPTIONS fipsinstall_options[] = {
  45     OPT_SECTION("General"),
  46     {"help", OPT_HELP, '-', "Display this summary"},
  47     {"verify", OPT_VERIFY, '-',
  48         "Verify a config file instead of generating one"},
  49     {"module", OPT_MODULE, '<', "File name of the provider module"},
  50     {"provider_name", OPT_PROV_NAME, 's', "FIPS provider name"},
  51     {"section_name", OPT_SECTION_NAME, 's',
  52      "FIPS Provider config section name (optional)"},
  53
  54     OPT_SECTION("Input"),
  55     {"in", OPT_IN, '<', "Input config file, used when verifying"},
  56
  57     OPT_SECTION("Output"),
  58     {"out", OPT_OUT, '>', "Output config file, used when generating"},
  59     {"mac_name", OPT_MAC_NAME, 's', "MAC name"},
  60     {"macopt", OPT_MACOPT, 's', "MAC algorithm parameters in n:v form. "
  61                                 "See 'PARAMETER NAMES' in the EVP_MAC_ docs"},
  62     {"noout", OPT_NO_LOG, '-', "Disable logging of self test events"},
  63     {"corrupt_desc", OPT_CORRUPT_DESC, 's', "Corrupt a self test by description"},
  64     {"corrupt_type", OPT_CORRUPT_TYPE, 's', "Corrupt a self test by type"},
  65     {"config", OPT_CONFIG, '<', "The parent config to verify"},
  66     {"quiet", OPT_QUIET, '-', "No messages, just exit status"},
  67     {NULL}
  68 };
  69
  70 static int do_mac(EVP_MAC_CTX *ctx, unsigned char *tmp, BIO *in,
  71                   unsigned char *out, size_t *out_len)
  72 {
  73     int ret = 0;
  74     int i;
  75     size_t outsz = *out_len;
  76
  77     if (!EVP_MAC_init(ctx))
  78         goto err;
  79     if (EVP_MAC_size(ctx) > outsz)
  80         goto end;
  81     while ((i = BIO_read(in, (char *)tmp, BUFSIZE)) != 0) {
  82         if (i < 0 || !EVP_MAC_update(ctx, tmp, i))
  83             goto err;
  84     }
  85 end:
  86     if (!EVP_MAC_final(ctx, out, out_len, outsz))
  87         goto err;
  88     ret = 1;
  89 err:
  90     return ret;
  91 }
  92
  93 static int load_fips_prov_and_run_self_test(const char *prov_name)
  94 {
  95     int ret = 0;
  96     OSSL_PROVIDER *prov = NULL;
  97
  98     prov = OSSL_PROVIDER_load(NULL, prov_name);
  99     if (prov == NULL) {
 100         BIO_printf(bio_err, "Failed to load FIPS module\n");
 101         goto end;
 102     }
 103     ret = 1;
 104 end:
 105     OSSL_PROVIDER_unload(prov);
 106     return ret;
 107 }
 108
 109 static int print_mac(BIO *bio, const char *label, const unsigned char *mac,
 110                      size_t len)
 111 {
 112     int ret;
 113     char *hexstr = NULL;
 114
 115     hexstr = OPENSSL_buf2hexstr(mac, (long)len);
 116     if (hexstr == NULL)
 117         return 0;
 118     ret = BIO_printf(bio, "%s = %s\n", label, hexstr);
 119     OPENSSL_free(hexstr);
 120     return ret;
 121 }
 122
 123 static int write_config_header(BIO *out, const char *prov_name,
 124                                const char *section)
 125 {
 126     return BIO_printf(out, "openssl_conf = openssl_init\n\n")
 127            && BIO_printf(out, "[openssl_init]\n")
 128            && BIO_printf(out, "providers = provider_section\n\n")
 129            && BIO_printf(out, "[provider_section]\n")
 130            && BIO_printf(out, "%s = %s\n\n", prov_name, section);
 131 }
 132
 133 /*
 134  * Outputs a fips related config file that contains entries for the fips
 135  * module checksum and the installation indicator checksum.
 136  *
 137  * Returns 1 if the config file is written otherwise it returns 0 on error.
 138  */
 139 static int write_config_fips_section(BIO *out, const char *section,
 140                                      unsigned char *module_mac,
 141                                      size_t module_mac_len,
 142                                      unsigned char *install_mac,
 143                                      size_t install_mac_len)
 144 {
 145     int ret = 0;
 146
 147     if (!(BIO_printf(out, "[%s]\n", section) > 0
 148           && BIO_printf(out, "activate = 1\n") > 0
 149           && BIO_printf(out, "%s = %s\n", OSSL_PROV_FIPS_PARAM_INSTALL_VERSION,
 150                         VERSION_VAL) > 0
 151           && print_mac(out, OSSL_PROV_FIPS_PARAM_MODULE_MAC, module_mac,
 152                        module_mac_len)))
 153         goto end;
 154
 155     if (install_mac != NULL) {
 156         if (!(print_mac(out, OSSL_PROV_FIPS_PARAM_INSTALL_MAC, install_mac,
 157                       install_mac_len)
 158               && BIO_printf(out, "%s = %s\n",
 159                             OSSL_PROV_FIPS_PARAM_INSTALL_STATUS,
 160                             INSTALL_STATUS_VAL) > 0))
 161         goto end;
 162     }
 163     ret = 1;
 164 end:
 165     return ret;
 166 }
 167
 168 static CONF *generate_config_and_load(const char *prov_name,
 169                                       const char *section,
 170                                       unsigned char *module_mac,
 171                                       size_t module_mac_len)
 172 {
 173     BIO *mem_bio = NULL;
 174     CONF *conf = NULL;
 175
 176     mem_bio = BIO_new(BIO_s_mem());
 177     if (mem_bio  == NULL)
 178         return 0;
 179     if (!write_config_header(mem_bio, prov_name, section)
 180          || !write_config_fips_section(mem_bio, section, module_mac,
 181                                        module_mac_len, NULL, 0))
 182         goto end;
 183
 184     conf = app_load_config_bio(mem_bio, NULL);
 185     if (conf == NULL)
 186         goto end;
 187
 188     if (CONF_modules_load(conf, NULL, 0) <= 0)
 189         goto end;
 190     BIO_free(mem_bio);
 191     return conf;
 192 end:
 193     NCONF_free(conf);
 194     BIO_free(mem_bio);
 195     return NULL;
 196 }
 197
 198 static void free_config_and_unload(CONF *conf)
 199 {
 200     if (conf != NULL) {
 201         NCONF_free(conf);
 202         CONF_modules_unload(1);
 203     }
 204 }
 205
 206 static int verify_module_load(const char *parent_config_file)
 207 {
 208     return OPENSSL_CTX_load_config(NULL, parent_config_file);
 209 }
 210
 211 /*
 212  * Returns 1 if the config file entries match the passed in module_mac and
 213  * install_mac values, otherwise it returns 0.
 214  */
 215 static int verify_config(const char *infile, const char *section,
 216                          unsigned char *module_mac, size_t module_mac_len,
 217                          unsigned char *install_mac, size_t install_mac_len)
 218 {
 219     int ret = 0;
 220     char *s = NULL;
 221     unsigned char *buf1 = NULL, *buf2 = NULL;
 222     long len;
 223     CONF *conf = NULL;
 224
 225     /* read in the existing values and check they match the saved values */
 226     conf = app_load_config(infile);
 227     if (conf == NULL)
 228         goto end;
 229
 230     s = NCONF_get_string(conf, section, OSSL_PROV_FIPS_PARAM_INSTALL_VERSION);
 231     if (s == NULL || strcmp(s, VERSION_VAL) != 0) {
 232         BIO_printf(bio_err, "version not found\n");
 233         goto end;
 234     }
 235     s = NCONF_get_string(conf, section, OSSL_PROV_FIPS_PARAM_INSTALL_STATUS);
 236     if (s == NULL || strcmp(s, INSTALL_STATUS_VAL) != 0) {
 237         BIO_printf(bio_err, "install status not found\n");
 238         goto end;
 239     }
 240     s = NCONF_get_string(conf, section, OSSL_PROV_FIPS_PARAM_MODULE_MAC);
 241     if (s == NULL) {
 242         BIO_printf(bio_err, "Module integrity MAC not found\n");
 243         goto end;
 244     }
 245     buf1 = OPENSSL_hexstr2buf(s, &len);
 246     if (buf1 == NULL
 247             || (size_t)len != module_mac_len
 248             || memcmp(module_mac, buf1, module_mac_len) != 0) {
 249         BIO_printf(bio_err, "Module integrity mismatch\n");
 250         goto end;
 251     }
 252     s = NCONF_get_string(conf, section, OSSL_PROV_FIPS_PARAM_INSTALL_MAC);
 253     if (s == NULL) {
 254         BIO_printf(bio_err, "Install indicator MAC not found\n");
 255         goto end;
 256     }
 257     buf2 = OPENSSL_hexstr2buf(s, &len);
 258     if (buf2 == NULL
 259             || (size_t)len != install_mac_len
 260             || memcmp(install_mac, buf2, install_mac_len) != 0) {
 261         BIO_printf(bio_err, "Install indicator status mismatch\n");
 262         goto end;
 263     }
 264     ret = 1;
 265 end:
 266     OPENSSL_free(buf1);
 267     OPENSSL_free(buf2);
 268     NCONF_free(conf);
 269     return ret;
 270 }
 271
 272 int fipsinstall_main(int argc, char **argv)
 273 {
 274     int ret = 1, verify = 0, gotkey = 0, gotdigest = 0;
 275     const char *section_name = "fips_sect";
 276     const char *mac_name = "HMAC";
 277     const char *prov_name = "fips";
 278     BIO *module_bio = NULL, *mem_bio = NULL, *fout = NULL;
 279     char *in_fname = NULL, *out_fname = NULL, *prog;
 280     char *module_fname = NULL, *parent_config = NULL;
 281     EVP_MAC_CTX *ctx = NULL, *ctx2 = NULL;
 282     STACK_OF(OPENSSL_STRING) *opts = NULL;
 283     OPTION_CHOICE o;
 284     unsigned char *read_buffer = NULL;
 285     unsigned char module_mac[EVP_MAX_MD_SIZE];
 286     size_t module_mac_len = EVP_MAX_MD_SIZE;
 287     unsigned char install_mac[EVP_MAX_MD_SIZE];
 288     size_t install_mac_len = EVP_MAX_MD_SIZE;
 289     EVP_MAC *mac = NULL;
 290     CONF *conf = NULL;
 291
 292     if ((opts = sk_OPENSSL_STRING_new_null()) == NULL)
 293         goto end;
 294
 295     prog = opt_init(argc, argv, fipsinstall_options);
 296     while ((o = opt_next()) != OPT_EOF) {
 297         switch (o) {
 298         case OPT_EOF:
 299         case OPT_ERR:
 300 opthelp:
 301             BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
 302             goto cleanup;
 303         case OPT_HELP:
 304             opt_help(fipsinstall_options);
 305             ret = 0;
 306             goto end;
 307         case OPT_IN:
 308             in_fname = opt_arg();
 309             break;
 310         case OPT_OUT:
 311             out_fname = opt_arg();
 312             break;
 313         case OPT_QUIET:
 314             quiet = 1;
 315             /* FALLTHROUGH */
 316         case OPT_NO_LOG:
 317             self_test_log = 0;
 318             break;
 319         case OPT_CORRUPT_DESC:
 320             self_test_corrupt_desc = opt_arg();
 321             break;
 322         case OPT_CORRUPT_TYPE:
 323             self_test_corrupt_type = opt_arg();
 324             break;
 325         case OPT_PROV_NAME:
 326             prov_name = opt_arg();
 327             break;
 328         case OPT_MODULE:
 329             module_fname = opt_arg();
 330             break;
 331         case OPT_SECTION_NAME:
 332             section_name = opt_arg();
 333             break;
 334         case OPT_MAC_NAME:
 335             mac_name = opt_arg();
 336             break;
 337         case OPT_CONFIG:
 338             parent_config = opt_arg();
 339             break;
 340         case OPT_MACOPT:
 341             if (!sk_OPENSSL_STRING_push(opts, opt_arg()))
 342                 goto opthelp;
 343             if (strncmp(opt_arg(), "hexkey:", 7) == 0)
 344                 gotkey = 1;
 345             else if (strncmp(opt_arg(), "digest:", 7) == 0)
 346                 gotdigest = 1;
 347             break;
 348         case OPT_VERIFY:
 349             verify = 1;
 350             break;
 351         }
 352     }
 353     argc = opt_num_rest();
 354
 355     if (parent_config != NULL) {
 356         /* Test that a parent config can load the module */
 357         if (verify_module_load(parent_config)) {
 358             ret = OSSL_PROVIDER_available(NULL, prov_name) ? 0 : 1;
 359             if (!quiet)
 360                 BIO_printf(bio_out, "FIPS provider is %s\n",
 361                            ret == 0 ? "available" : " not available");
 362         }
 363         goto end;
 364     }
 365     if (module_fname == NULL
 366         || (verify && in_fname == NULL)
 367         || (!verify && out_fname == NULL)
 368         || argc != 0)
 369         goto opthelp;
 370
 371     if (self_test_log
 372             || self_test_corrupt_desc != NULL
 373             || self_test_corrupt_type != NULL)
 374         OSSL_SELF_TEST_set_callback(NULL, self_test_events, NULL);
 375
 376     /* Use the default FIPS HMAC digest and key if not specified. */
 377     if (!gotdigest && !sk_OPENSSL_STRING_push(opts, "digest:SHA256"))
 378         goto end;
 379     if (!gotkey && !sk_OPENSSL_STRING_push(opts, "hexkey:" FIPS_KEY_STRING))
 380         goto end;
 381
 382     module_bio = bio_open_default(module_fname, 'r', FORMAT_BINARY);
 383     if (module_bio == NULL) {
 384         BIO_printf(bio_err, "Failed to open module file\n");
 385         goto end;
 386     }
 387
 388     read_buffer = app_malloc(BUFSIZE, "I/O buffer");
 389     if (read_buffer == NULL)
 390         goto end;
 391
 392     mac = EVP_MAC_fetch(NULL, mac_name, NULL);
 393     if (mac == NULL) {
 394         BIO_printf(bio_err, "Unable to get MAC of type %s\n", mac_name);
 395         goto end;
 396     }
 397
 398     ctx = EVP_MAC_CTX_new(mac);
 399     if (ctx == NULL) {
 400         BIO_printf(bio_err, "Unable to create MAC CTX for module check\n");
 401         goto end;
 402     }
 403
 404     if (opts != NULL) {
 405         int ok = 1;
 406         OSSL_PARAM *params =
 407             app_params_new_from_opts(opts, EVP_MAC_settable_ctx_params(mac));
 408
 409         if (params == NULL)
 410             goto end;
 411
 412         if (!EVP_MAC_CTX_set_params(ctx, params)) {
 413             BIO_printf(bio_err, "MAC parameter error\n");
 414             ERR_print_errors(bio_err);
 415             ok = 0;
 416         }
 417         app_params_free(params);
 418         if (!ok)
 419             goto end;
 420     }
 421
 422     ctx2 = EVP_MAC_CTX_dup(ctx);
 423     if (ctx2 == NULL) {
 424         BIO_printf(bio_err, "Unable to create MAC CTX for install indicator\n");
 425         goto end;
 426     }
 427
 428     if (!do_mac(ctx, read_buffer, module_bio, module_mac, &module_mac_len))
 429         goto end;
 430
 431     mem_bio = BIO_new_mem_buf((const void *)INSTALL_STATUS_VAL,
 432                               strlen(INSTALL_STATUS_VAL));
 433     if (mem_bio == NULL) {
 434         BIO_printf(bio_err, "Unable to create memory BIO\n");
 435         goto end;
 436     }
 437     if (!do_mac(ctx2, read_buffer, mem_bio, install_mac, &install_mac_len))
 438         goto end;
 439
 440     if (verify) {
 441         if (!verify_config(in_fname, section_name, module_mac, module_mac_len,
 442                            install_mac, install_mac_len))
 443             goto end;
 444         if (!quiet)
 445             BIO_printf(bio_out, "VERIFY PASSED\n");
 446     } else {
 447
 448         conf = generate_config_and_load(prov_name, section_name, module_mac,
 449                                         module_mac_len);
 450         if (conf == NULL)
 451             goto end;
 452         if (!load_fips_prov_and_run_self_test(prov_name))
 453             goto end;
 454
 455         fout = bio_open_default(out_fname, 'w', FORMAT_TEXT);
 456         if (fout == NULL) {
 457             BIO_printf(bio_err, "Failed to open file\n");
 458             goto end;
 459         }
 460         if (!write_config_fips_section(fout, section_name, module_mac,
 461                                        module_mac_len, install_mac,
 462                                        install_mac_len))
 463             goto end;
 464         if (!quiet)
 465             BIO_printf(bio_out, "INSTALL PASSED\n");
 466     }
 467
 468     ret = 0;
 469 end:
 470     if (ret == 1) {
 471         if (!quiet)
 472             BIO_printf(bio_err, "%s FAILED\n", verify ? "VERIFY" : "INSTALL");
 473         ERR_print_errors(bio_err);
 474     }
 475
 476 cleanup:
 477     BIO_free(fout);
 478     BIO_free(mem_bio);
 479     BIO_free(module_bio);
 480     sk_OPENSSL_STRING_free(opts);
 481     EVP_MAC_free(mac);
 482     EVP_MAC_CTX_free(ctx2);
 483     EVP_MAC_CTX_free(ctx);
 484     OPENSSL_free(read_buffer);
 485     free_config_and_unload(conf);
 486     return ret;
 487 }
 488
 489 static int self_test_events(const OSSL_PARAM params[], void *arg)
 490 {
 491     const OSSL_PARAM *p = NULL;
 492     const char *phase = NULL, *type = NULL, *desc = NULL;
 493     int ret = 0;
 494
 495     p = OSSL_PARAM_locate_const(params, OSSL_PROV_PARAM_SELF_TEST_PHASE);
 496     if (p == NULL || p->data_type != OSSL_PARAM_UTF8_STRING)
 497         goto err;
 498     phase = (const char *)p->data;
 499
 500     p = OSSL_PARAM_locate_const(params, OSSL_PROV_PARAM_SELF_TEST_DESC);
 501     if (p == NULL || p->data_type != OSSL_PARAM_UTF8_STRING)
 502         goto err;
 503     desc = (const char *)p->data;
 504
 505     p = OSSL_PARAM_locate_const(params, OSSL_PROV_PARAM_SELF_TEST_TYPE);
 506     if (p == NULL || p->data_type != OSSL_PARAM_UTF8_STRING)
 507         goto err;
 508     type = (const char *)p->data;
 509
 510     if (self_test_log) {
 511         if (strcmp(phase, OSSL_SELF_TEST_PHASE_START) == 0)
 512             BIO_printf(bio_out, "%s : (%s) : ", desc, type);
 513         else if (strcmp(phase, OSSL_SELF_TEST_PHASE_PASS) == 0
 514                  || strcmp(phase, OSSL_SELF_TEST_PHASE_FAIL) == 0)
 515             BIO_printf(bio_out, "%s\n", phase);
 516     }
 517     /*
 518      * The self test code will internally corrupt the KAT test result if an
 519      * error is returned during the corrupt phase.
 520      */
 521     if (strcmp(phase, OSSL_SELF_TEST_PHASE_CORRUPT) == 0
 522             && (self_test_corrupt_desc != NULL
 523                 || self_test_corrupt_type != NULL)) {
 524         if (self_test_corrupt_desc != NULL
 525                 && strcmp(self_test_corrupt_desc, desc) != 0)
 526             goto end;
 527         if (self_test_corrupt_type != NULL
 528                 && strcmp(self_test_corrupt_type, type) != 0)
 529             goto end;
 530         BIO_printf(bio_out, "%s ", phase);
 531         goto err;
 532     }
 533 end:
 534     ret = 1;
 535 err:
 536     return ret;
 537 }