e0fe43e8b7492d9ef46e420db9b98e397ed0bf8a
[openssl.git] / 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 "apps.h"
19 #include "progs.h"
20
21 DEFINE_STACK_OF_STRING()
22
23 #define BUFSIZE 4096
24 #define DEFAULT_MAC_NAME "HMAC"
25 #define DEFAULT_FIPS_SECTION "fips_check_section"
26
27 /* Configuration file values */
28 #define VERSION_KEY  "version"
29 #define VERSION_VAL  "1"
30 #define INSTALL_STATUS_VAL "INSTALL_SELF_TEST_KATS_RUN"
31
32 static OSSL_CALLBACK self_test_events;
33 static char *self_test_corrupt_desc = NULL;
34 static char *self_test_corrupt_type = NULL;
35 static int self_test_log = 1;
36 static int quiet = 0;
37
38 typedef enum OPTION_choice {
39     OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
40     OPT_IN, OPT_OUT, OPT_MODULE,
41     OPT_PROV_NAME, OPT_SECTION_NAME, OPT_MAC_NAME, OPT_MACOPT, OPT_VERIFY,
42     OPT_NO_LOG, OPT_CORRUPT_DESC, OPT_CORRUPT_TYPE, OPT_QUIET
43 } OPTION_CHOICE;
44
45 const OPTIONS fipsinstall_options[] = {
46     OPT_SECTION("General"),
47     {"help", OPT_HELP, '-', "Display this summary"},
48     {"verify", OPT_VERIFY, '-',
49         "Verify a config file instead of generating one"},
50     {"module", OPT_MODULE, '<', "File name of the provider module"},
51     {"provider_name", OPT_PROV_NAME, 's', "FIPS provider name"},
52     {"section_name", OPT_SECTION_NAME, 's',
53      "FIPS Provider config section name (optional)"},
54
55     OPT_SECTION("Input"),
56     {"in", OPT_IN, '<', "Input config file, used when verifying"},
57
58     OPT_SECTION("Output"),
59     {"out", OPT_OUT, '>', "Output config file, used when generating"},
60     {"mac_name", OPT_MAC_NAME, 's', "MAC name"},
61     {"macopt", OPT_MACOPT, 's', "MAC algorithm parameters in n:v form. "
62                                 "See 'PARAMETER NAMES' in the EVP_MAC_ docs"},
63     {"noout", OPT_NO_LOG, '-', "Disable logging of self test events"},
64     {"corrupt_desc", OPT_CORRUPT_DESC, 's', "Corrupt a self test by description"},
65     {"corrupt_type", OPT_CORRUPT_TYPE, 's', "Corrupt a self test by type"},
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 /*
207  * Returns 1 if the config file entries match the passed in module_mac and
208  * install_mac values, otherwise it returns 0.
209  */
210 static int verify_config(const char *infile, const char *section,
211                          unsigned char *module_mac, size_t module_mac_len,
212                          unsigned char *install_mac, size_t install_mac_len)
213 {
214     int ret = 0;
215     char *s = NULL;
216     unsigned char *buf1 = NULL, *buf2 = NULL;
217     long len;
218     CONF *conf = NULL;
219
220     /* read in the existing values and check they match the saved values */
221     conf = app_load_config(infile);
222     if (conf == NULL)
223         goto end;
224
225     s = NCONF_get_string(conf, section, OSSL_PROV_FIPS_PARAM_INSTALL_VERSION);
226     if (s == NULL || strcmp(s, VERSION_VAL) != 0) {
227         BIO_printf(bio_err, "version not found\n");
228         goto end;
229     }
230     s = NCONF_get_string(conf, section, OSSL_PROV_FIPS_PARAM_INSTALL_STATUS);
231     if (s == NULL || strcmp(s, INSTALL_STATUS_VAL) != 0) {
232         BIO_printf(bio_err, "install status not found\n");
233         goto end;
234     }
235     s = NCONF_get_string(conf, section, OSSL_PROV_FIPS_PARAM_MODULE_MAC);
236     if (s == NULL) {
237         BIO_printf(bio_err, "Module integrity MAC not found\n");
238         goto end;
239     }
240     buf1 = OPENSSL_hexstr2buf(s, &len);
241     if (buf1 == NULL
242             || (size_t)len != module_mac_len
243             || memcmp(module_mac, buf1, module_mac_len) != 0) {
244         BIO_printf(bio_err, "Module integrity mismatch\n");
245         goto end;
246     }
247     s = NCONF_get_string(conf, section, OSSL_PROV_FIPS_PARAM_INSTALL_MAC);
248     if (s == NULL) {
249         BIO_printf(bio_err, "Install indicator MAC not found\n");
250         goto end;
251     }
252     buf2 = OPENSSL_hexstr2buf(s, &len);
253     if (buf2 == NULL
254             || (size_t)len != install_mac_len
255             || memcmp(install_mac, buf2, install_mac_len) != 0) {
256         BIO_printf(bio_err, "Install indicator status mismatch\n");
257         goto end;
258     }
259     ret = 1;
260 end:
261     OPENSSL_free(buf1);
262     OPENSSL_free(buf2);
263     NCONF_free(conf);
264     return ret;
265 }
266
267 int fipsinstall_main(int argc, char **argv)
268 {
269     int ret = 1, verify = 0;
270     BIO *module_bio = NULL, *mem_bio = NULL, *fout = NULL;
271     char *in_fname = NULL, *out_fname = NULL, *prog, *section_name = NULL;
272     char *prov_name = NULL, *module_fname = NULL;
273     static const char *mac_name = DEFAULT_MAC_NAME;
274     EVP_MAC_CTX *ctx = NULL, *ctx2 = NULL;
275     STACK_OF(OPENSSL_STRING) *opts = NULL;
276     OPTION_CHOICE o;
277     unsigned char *read_buffer = NULL;
278     unsigned char module_mac[EVP_MAX_MD_SIZE];
279     size_t module_mac_len = EVP_MAX_MD_SIZE;
280     unsigned char install_mac[EVP_MAX_MD_SIZE];
281     size_t install_mac_len = EVP_MAX_MD_SIZE;
282     EVP_MAC *mac = NULL;
283     CONF *conf = NULL;
284
285     section_name = DEFAULT_FIPS_SECTION;
286
287     prog = opt_init(argc, argv, fipsinstall_options);
288     while ((o = opt_next()) != OPT_EOF) {
289         switch (o) {
290         case OPT_EOF:
291         case OPT_ERR:
292 opthelp:
293             BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
294             goto cleanup;
295         case OPT_HELP:
296             opt_help(fipsinstall_options);
297             ret = 0;
298             goto end;
299         case OPT_IN:
300             in_fname = opt_arg();
301             break;
302         case OPT_OUT:
303             out_fname = opt_arg();
304             break;
305         case OPT_QUIET:
306             quiet = 1;
307             /* FALLTHROUGH */
308         case OPT_NO_LOG:
309             self_test_log = 0;
310             break;
311         case OPT_CORRUPT_DESC:
312             self_test_corrupt_desc = opt_arg();
313             break;
314         case OPT_CORRUPT_TYPE:
315             self_test_corrupt_type = opt_arg();
316             break;
317         case OPT_PROV_NAME:
318             prov_name = opt_arg();
319             break;
320         case OPT_MODULE:
321             module_fname = opt_arg();
322             break;
323         case OPT_SECTION_NAME:
324             section_name = opt_arg();
325             break;
326         case OPT_MAC_NAME:
327             mac_name = opt_arg();
328             break;
329         case OPT_MACOPT:
330             if (opts == NULL)
331                 opts = sk_OPENSSL_STRING_new_null();
332             if (opts == NULL || !sk_OPENSSL_STRING_push(opts, opt_arg()))
333                 goto opthelp;
334             break;
335         case OPT_VERIFY:
336             verify = 1;
337             break;
338         }
339     }
340     argc = opt_num_rest();
341     if (module_fname == NULL
342         || (verify && in_fname == NULL)
343         || (!verify && (out_fname == NULL || prov_name == NULL))
344         || opts == NULL
345         || argc != 0)
346         goto opthelp;
347
348     if (self_test_log
349             || self_test_corrupt_desc != NULL
350             || self_test_corrupt_type != NULL)
351         OSSL_SELF_TEST_set_callback(NULL, self_test_events, NULL);
352
353     module_bio = bio_open_default(module_fname, 'r', FORMAT_BINARY);
354     if (module_bio == NULL) {
355         BIO_printf(bio_err, "Failed to open module file\n");
356         goto end;
357     }
358
359     read_buffer = app_malloc(BUFSIZE, "I/O buffer");
360     if (read_buffer == NULL)
361         goto end;
362
363     mac = EVP_MAC_fetch(NULL, mac_name, NULL);
364     if (mac == NULL) {
365         BIO_printf(bio_err, "Unable to get MAC of type %s\n", mac_name);
366         goto end;
367     }
368
369     ctx = EVP_MAC_new_ctx(mac);
370     if (ctx == NULL) {
371         BIO_printf(bio_err, "Unable to create MAC CTX for module check\n");
372         goto end;
373     }
374
375     if (opts != NULL) {
376         int ok = 1;
377         OSSL_PARAM *params =
378             app_params_new_from_opts(opts, EVP_MAC_settable_ctx_params(mac));
379
380         if (params == NULL)
381             goto end;
382
383         if (!EVP_MAC_set_ctx_params(ctx, params)) {
384             BIO_printf(bio_err, "MAC parameter error\n");
385             ERR_print_errors(bio_err);
386             ok = 0;
387         }
388         app_params_free(params);
389         if (!ok)
390             goto end;
391     }
392
393     ctx2 = EVP_MAC_dup_ctx(ctx);
394     if (ctx2 == NULL) {
395         BIO_printf(bio_err, "Unable to create MAC CTX for install indicator\n");
396         goto end;
397     }
398
399     if (!do_mac(ctx, read_buffer, module_bio, module_mac, &module_mac_len))
400         goto end;
401
402     mem_bio = BIO_new_mem_buf((const void *)INSTALL_STATUS_VAL,
403                               strlen(INSTALL_STATUS_VAL));
404     if (mem_bio == NULL) {
405         BIO_printf(bio_err, "Unable to create memory BIO\n");
406         goto end;
407     }
408     if (!do_mac(ctx2, read_buffer, mem_bio, install_mac, &install_mac_len))
409         goto end;
410
411     if (verify) {
412         if (!verify_config(in_fname, section_name, module_mac, module_mac_len,
413                            install_mac, install_mac_len))
414             goto end;
415         if (!quiet)
416             BIO_printf(bio_out, "VERIFY PASSED\n");
417     } else {
418
419         conf = generate_config_and_load(prov_name, section_name, module_mac,
420                                         module_mac_len);
421         if (conf == NULL)
422             goto end;
423         if (!load_fips_prov_and_run_self_test(prov_name))
424             goto end;
425
426         fout = bio_open_default(out_fname, 'w', FORMAT_TEXT);
427         if (fout == NULL) {
428             BIO_printf(bio_err, "Failed to open file\n");
429             goto end;
430         }
431         if (!write_config_fips_section(fout, section_name, module_mac,
432                                        module_mac_len, install_mac,
433                                        install_mac_len))
434             goto end;
435         if (!quiet)
436             BIO_printf(bio_out, "INSTALL PASSED\n");
437     }
438
439     ret = 0;
440 end:
441     if (ret == 1) {
442         if (!quiet)
443             BIO_printf(bio_err, "%s FAILED\n", verify ? "VERIFY" : "INSTALL");
444         ERR_print_errors(bio_err);
445     }
446
447 cleanup:
448     BIO_free(fout);
449     BIO_free(mem_bio);
450     BIO_free(module_bio);
451     sk_OPENSSL_STRING_free(opts);
452     EVP_MAC_free(mac);
453     EVP_MAC_free_ctx(ctx2);
454     EVP_MAC_free_ctx(ctx);
455     OPENSSL_free(read_buffer);
456     free_config_and_unload(conf);
457     return ret;
458 }
459
460 static int self_test_events(const OSSL_PARAM params[], void *arg)
461 {
462     const OSSL_PARAM *p = NULL;
463     const char *phase = NULL, *type = NULL, *desc = NULL;
464     int ret = 0;
465
466     p = OSSL_PARAM_locate_const(params, OSSL_PROV_PARAM_SELF_TEST_PHASE);
467     if (p == NULL || p->data_type != OSSL_PARAM_UTF8_STRING)
468         goto err;
469     phase = (const char *)p->data;
470
471     p = OSSL_PARAM_locate_const(params, OSSL_PROV_PARAM_SELF_TEST_DESC);
472     if (p == NULL || p->data_type != OSSL_PARAM_UTF8_STRING)
473         goto err;
474     desc = (const char *)p->data;
475
476     p = OSSL_PARAM_locate_const(params, OSSL_PROV_PARAM_SELF_TEST_TYPE);
477     if (p == NULL || p->data_type != OSSL_PARAM_UTF8_STRING)
478         goto err;
479     type = (const char *)p->data;
480
481     if (self_test_log) {
482         if (strcmp(phase, OSSL_SELF_TEST_PHASE_START) == 0)
483             BIO_printf(bio_out, "%s : (%s) : ", desc, type);
484         else if (strcmp(phase, OSSL_SELF_TEST_PHASE_PASS) == 0
485                  || strcmp(phase, OSSL_SELF_TEST_PHASE_FAIL) == 0)
486             BIO_printf(bio_out, "%s\n", phase);
487     }
488     /*
489      * The self test code will internally corrupt the KAT test result if an
490      * error is returned during the corrupt phase.
491      */
492     if (strcmp(phase, OSSL_SELF_TEST_PHASE_CORRUPT) == 0
493             && (self_test_corrupt_desc != NULL
494                 || self_test_corrupt_type != NULL)) {
495         if (self_test_corrupt_desc != NULL
496                 && strcmp(self_test_corrupt_desc, desc) != 0)
497             goto end;
498         if (self_test_corrupt_type != NULL
499                 && strcmp(self_test_corrupt_type, type) != 0)
500             goto end;
501         BIO_printf(bio_out, "%s ", phase);
502         goto err;
503     }
504 end:
505     ret = 1;
506 err:
507     return ret;
508 }