apps/list.c

   1 /*
   2  * Copyright 1995-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 /* We need to use some deprecated APIs */
  11 #define OPENSSL_SUPPRESS_DEPRECATED
  12
  13 #include <string.h>
  14 #include <openssl/evp.h>
  15 #include <openssl/err.h>
  16 #include <openssl/provider.h>
  17 #include <openssl/safestack.h>
  18 #include <openssl/kdf.h>
  19 #include <openssl/encoder.h>
  20 #include <openssl/decoder.h>
  21 #include <openssl/core_names.h>
  22 #include <openssl/rand.h>
  23 #include "apps.h"
  24 #include "app_params.h"
  25 #include "progs.h"
  26 #include "opt.h"
  27 #include "names.h"
  28
  29 static int verbose = 0;
  30 static const char *select_name = NULL;
  31
  32 static void legacy_cipher_fn(const EVP_CIPHER *c,
  33                              const char *from, const char *to, void *arg)
  34 {
  35     if (select_name != NULL
  36         && (c == NULL
  37             || strcasecmp(select_name,  EVP_CIPHER_name(c)) != 0))
  38         return;
  39     if (c != NULL) {
  40         BIO_printf(arg, "  %s\n", EVP_CIPHER_name(c));
  41     } else {
  42         if (from == NULL)
  43             from = "<undefined>";
  44         if (to == NULL)
  45             to = "<undefined>";
  46         BIO_printf(arg, "  %s => %s\n", from, to);
  47     }
  48 }
  49
  50 DEFINE_STACK_OF(EVP_CIPHER)
  51 static int cipher_cmp(const EVP_CIPHER * const *a,
  52                       const EVP_CIPHER * const *b)
  53 {
  54     int ret = EVP_CIPHER_number(*a) - EVP_CIPHER_number(*b);
  55
  56     if (ret == 0)
  57         ret = strcmp(OSSL_PROVIDER_name(EVP_CIPHER_provider(*a)),
  58                      OSSL_PROVIDER_name(EVP_CIPHER_provider(*b)));
  59
  60     return ret;
  61 }
  62
  63 static void collect_ciphers(EVP_CIPHER *cipher, void *stack)
  64 {
  65     STACK_OF(EVP_CIPHER) *cipher_stack = stack;
  66
  67     if (sk_EVP_CIPHER_push(cipher_stack, cipher) > 0)
  68         EVP_CIPHER_up_ref(cipher);
  69 }
  70
  71 static void list_ciphers(void)
  72 {
  73     STACK_OF(EVP_CIPHER) *ciphers = sk_EVP_CIPHER_new(cipher_cmp);
  74     int i;
  75
  76     if (ciphers == NULL) {
  77         BIO_printf(bio_err, "ERROR: Memory allocation\n");
  78         return;
  79     }
  80     BIO_printf(bio_out, "Legacy:\n");
  81     EVP_CIPHER_do_all_sorted(legacy_cipher_fn, bio_out);
  82
  83     BIO_printf(bio_out, "Provided:\n");
  84     EVP_CIPHER_do_all_provided(NULL, collect_ciphers, ciphers);
  85     sk_EVP_CIPHER_sort(ciphers);
  86     for (i = 0; i < sk_EVP_CIPHER_num(ciphers); i++) {
  87         const EVP_CIPHER *c = sk_EVP_CIPHER_value(ciphers, i);
  88         STACK_OF(OPENSSL_CSTRING) *names = NULL;
  89
  90         if (select_name != NULL && !EVP_CIPHER_is_a(c, select_name))
  91             continue;
  92
  93         names = sk_OPENSSL_CSTRING_new(name_cmp);
  94         EVP_CIPHER_names_do_all(c, collect_names, names);
  95         BIO_printf(bio_out, "  ");
  96         print_names(bio_out, names);
  97         sk_OPENSSL_CSTRING_free(names);
  98
  99         BIO_printf(bio_out, " @ %s\n",
 100                    OSSL_PROVIDER_name(EVP_CIPHER_provider(c)));
 101
 102         if (verbose) {
 103             print_param_types("retrievable algorithm parameters",
 104                               EVP_CIPHER_gettable_params(c), 4);
 105             print_param_types("retrievable operation parameters",
 106                               EVP_CIPHER_gettable_ctx_params(c), 4);
 107             print_param_types("settable operation parameters",
 108                               EVP_CIPHER_settable_ctx_params(c), 4);
 109         }
 110     }
 111     sk_EVP_CIPHER_pop_free(ciphers, EVP_CIPHER_free);
 112 }
 113
 114 static void list_md_fn(const EVP_MD *m,
 115                        const char *from, const char *to, void *arg)
 116 {
 117     if (m != NULL) {
 118         BIO_printf(arg, "  %s\n", EVP_MD_name(m));
 119     } else {
 120         if (from == NULL)
 121             from = "<undefined>";
 122         if (to == NULL)
 123             to = "<undefined>";
 124         BIO_printf((BIO *)arg, "  %s => %s\n", from, to);
 125     }
 126 }
 127
 128 DEFINE_STACK_OF(EVP_MD)
 129 static int md_cmp(const EVP_MD * const *a, const EVP_MD * const *b)
 130 {
 131     int ret = EVP_MD_number(*a) - EVP_MD_number(*b);
 132
 133     if (ret == 0)
 134         ret = strcmp(OSSL_PROVIDER_name(EVP_MD_provider(*a)),
 135                      OSSL_PROVIDER_name(EVP_MD_provider(*b)));
 136
 137     return ret;
 138 }
 139
 140 static void collect_digests(EVP_MD *md, void *stack)
 141 {
 142     STACK_OF(EVP_MD) *digest_stack = stack;
 143
 144     if (sk_EVP_MD_push(digest_stack, md) > 0)
 145         EVP_MD_up_ref(md);
 146 }
 147
 148 static void list_digests(void)
 149 {
 150     STACK_OF(EVP_MD) *digests = sk_EVP_MD_new(md_cmp);
 151     int i;
 152
 153     if (digests == NULL) {
 154         BIO_printf(bio_err, "ERROR: Memory allocation\n");
 155         return;
 156     }
 157     BIO_printf(bio_out, "Legacy:\n");
 158     EVP_MD_do_all_sorted(list_md_fn, bio_out);
 159
 160     BIO_printf(bio_out, "Provided:\n");
 161     EVP_MD_do_all_provided(NULL, collect_digests, digests);
 162     sk_EVP_MD_sort(digests);
 163     for (i = 0; i < sk_EVP_MD_num(digests); i++) {
 164         const EVP_MD *m = sk_EVP_MD_value(digests, i);
 165         STACK_OF(OPENSSL_CSTRING) *names = NULL;
 166
 167         if (select_name != NULL && !EVP_MD_is_a(m, select_name))
 168             continue;
 169
 170         names = sk_OPENSSL_CSTRING_new(name_cmp);
 171         EVP_MD_names_do_all(m, collect_names, names);
 172         BIO_printf(bio_out, "  ");
 173         print_names(bio_out, names);
 174         sk_OPENSSL_CSTRING_free(names);
 175
 176         BIO_printf(bio_out, " @ %s\n", OSSL_PROVIDER_name(EVP_MD_provider(m)));
 177
 178         if (verbose) {
 179             print_param_types("retrievable algorithm parameters",
 180                               EVP_MD_gettable_params(m), 4);
 181             print_param_types("retrievable operation parameters",
 182                               EVP_MD_gettable_ctx_params(m), 4);
 183             print_param_types("settable operation parameters",
 184                               EVP_MD_settable_ctx_params(m), 4);
 185         }
 186     }
 187     sk_EVP_MD_pop_free(digests, EVP_MD_free);
 188 }
 189
 190 DEFINE_STACK_OF(EVP_MAC)
 191 static int mac_cmp(const EVP_MAC * const *a, const EVP_MAC * const *b)
 192 {
 193     int ret = EVP_MAC_number(*a) - EVP_MAC_number(*b);
 194
 195     if (ret == 0)
 196         ret = strcmp(OSSL_PROVIDER_name(EVP_MAC_provider(*a)),
 197                      OSSL_PROVIDER_name(EVP_MAC_provider(*b)));
 198
 199     return ret;
 200 }
 201
 202 static void collect_macs(EVP_MAC *mac, void *stack)
 203 {
 204     STACK_OF(EVP_MAC) *mac_stack = stack;
 205
 206     if (sk_EVP_MAC_push(mac_stack, mac) > 0)
 207         EVP_MAC_up_ref(mac);
 208 }
 209
 210 static void list_macs(void)
 211 {
 212     STACK_OF(EVP_MAC) *macs = sk_EVP_MAC_new(mac_cmp);
 213     int i;
 214
 215     if (macs == NULL) {
 216         BIO_printf(bio_err, "ERROR: Memory allocation\n");
 217         return;
 218     }
 219     BIO_printf(bio_out, "Provided MACs:\n");
 220     EVP_MAC_do_all_provided(NULL, collect_macs, macs);
 221     sk_EVP_MAC_sort(macs);
 222     for (i = 0; i < sk_EVP_MAC_num(macs); i++) {
 223         const EVP_MAC *m = sk_EVP_MAC_value(macs, i);
 224         STACK_OF(OPENSSL_CSTRING) *names = NULL;
 225
 226         if (select_name != NULL && !EVP_MAC_is_a(m, select_name))
 227             continue;
 228
 229         names = sk_OPENSSL_CSTRING_new(name_cmp);
 230         EVP_MAC_names_do_all(m, collect_names, names);
 231         BIO_printf(bio_out, "  ");
 232         print_names(bio_out, names);
 233         sk_OPENSSL_CSTRING_free(names);
 234
 235         BIO_printf(bio_out, " @ %s\n", OSSL_PROVIDER_name(EVP_MAC_provider(m)));
 236
 237         if (verbose) {
 238             print_param_types("retrievable algorithm parameters",
 239                               EVP_MAC_gettable_params(m), 4);
 240             print_param_types("retrievable operation parameters",
 241                               EVP_MAC_gettable_ctx_params(m), 4);
 242             print_param_types("settable operation parameters",
 243                               EVP_MAC_settable_ctx_params(m), 4);
 244         }
 245     }
 246     sk_EVP_MAC_pop_free(macs, EVP_MAC_free);
 247 }
 248
 249 /*
 250  * KDFs and PRFs
 251  */
 252 DEFINE_STACK_OF(EVP_KDF)
 253 static int kdf_cmp(const EVP_KDF * const *a, const EVP_KDF * const *b)
 254 {
 255     int ret = EVP_KDF_number(*a) - EVP_KDF_number(*b);
 256
 257     if (ret == 0)
 258         ret = strcmp(OSSL_PROVIDER_name(EVP_KDF_provider(*a)),
 259                      OSSL_PROVIDER_name(EVP_KDF_provider(*b)));
 260
 261     return ret;
 262 }
 263
 264 static void collect_kdfs(EVP_KDF *kdf, void *stack)
 265 {
 266     STACK_OF(EVP_KDF) *kdf_stack = stack;
 267
 268     sk_EVP_KDF_push(kdf_stack, kdf);
 269     EVP_KDF_up_ref(kdf);
 270 }
 271
 272 static void list_kdfs(void)
 273 {
 274     STACK_OF(EVP_KDF) *kdfs = sk_EVP_KDF_new(kdf_cmp);
 275     int i;
 276
 277     if (kdfs == NULL) {
 278         BIO_printf(bio_err, "ERROR: Memory allocation\n");
 279         return;
 280     }
 281     BIO_printf(bio_out, "Provided KDFs and PDFs:\n");
 282     EVP_KDF_do_all_provided(NULL, collect_kdfs, kdfs);
 283     sk_EVP_KDF_sort(kdfs);
 284     for (i = 0; i < sk_EVP_KDF_num(kdfs); i++) {
 285         const EVP_KDF *k = sk_EVP_KDF_value(kdfs, i);
 286         STACK_OF(OPENSSL_CSTRING) *names = NULL;
 287
 288         if (select_name != NULL && !EVP_KDF_is_a(k, select_name))
 289             continue;
 290
 291         names = sk_OPENSSL_CSTRING_new(name_cmp);
 292         EVP_KDF_names_do_all(k, collect_names, names);
 293         BIO_printf(bio_out, "  ");
 294         print_names(bio_out, names);
 295         sk_OPENSSL_CSTRING_free(names);
 296
 297         BIO_printf(bio_out, " @ %s\n", OSSL_PROVIDER_name(EVP_KDF_provider(k)));
 298
 299         if (verbose) {
 300             print_param_types("retrievable algorithm parameters",
 301                               EVP_KDF_gettable_params(k), 4);
 302             print_param_types("retrievable operation parameters",
 303                               EVP_KDF_gettable_ctx_params(k), 4);
 304             print_param_types("settable operation parameters",
 305                               EVP_KDF_settable_ctx_params(k), 4);
 306         }
 307     }
 308     sk_EVP_KDF_pop_free(kdfs, EVP_KDF_free);
 309 }
 310
 311 /*
 312  * RANDs
 313  */
 314 DEFINE_STACK_OF(EVP_RAND)
 315
 316 static int rand_cmp(const EVP_RAND * const *a, const EVP_RAND * const *b)
 317 {
 318     int ret = strcasecmp(EVP_RAND_name(*a), EVP_RAND_name(*b));
 319
 320     if (ret == 0)
 321         ret = strcmp(OSSL_PROVIDER_name(EVP_RAND_provider(*a)),
 322                      OSSL_PROVIDER_name(EVP_RAND_provider(*b)));
 323
 324     return ret;
 325 }
 326
 327 static void collect_rands(EVP_RAND *rand, void *stack)
 328 {
 329     STACK_OF(EVP_RAND) *rand_stack = stack;
 330
 331     sk_EVP_RAND_push(rand_stack, rand);
 332     EVP_RAND_up_ref(rand);
 333 }
 334
 335 static void list_random_generators(void)
 336 {
 337     STACK_OF(EVP_RAND) *rands = sk_EVP_RAND_new(rand_cmp);
 338     int i;
 339
 340     if (rands == NULL) {
 341         BIO_printf(bio_err, "ERROR: Memory allocation\n");
 342         return;
 343     }
 344     BIO_printf(bio_out, "Provided RNGs and seed sources:\n");
 345     EVP_RAND_do_all_provided(NULL, collect_rands, rands);
 346     sk_EVP_RAND_sort(rands);
 347     for (i = 0; i < sk_EVP_RAND_num(rands); i++) {
 348         const EVP_RAND *m = sk_EVP_RAND_value(rands, i);
 349
 350         if (select_name != NULL
 351             && strcasecmp(EVP_RAND_name(m), select_name) != 0)
 352             continue;
 353         BIO_printf(bio_out, "  %s", EVP_RAND_name(m));
 354         BIO_printf(bio_out, " @ %s\n", OSSL_PROVIDER_name(EVP_RAND_provider(m)));
 355
 356         if (verbose) {
 357             print_param_types("retrievable algorithm parameters",
 358                               EVP_RAND_gettable_params(m), 4);
 359             print_param_types("retrievable operation parameters",
 360                               EVP_RAND_gettable_ctx_params(m), 4);
 361             print_param_types("settable operation parameters",
 362                               EVP_RAND_settable_ctx_params(m), 4);
 363         }
 364     }
 365     sk_EVP_RAND_pop_free(rands, EVP_RAND_free);
 366 }
 367
 368 static void display_random(const char *name, EVP_RAND_CTX *drbg)
 369 {
 370     EVP_RAND *rand;
 371     uint64_t u;
 372     const char *p;
 373     const OSSL_PARAM *gettables;
 374     OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
 375     unsigned char buf[1000];
 376
 377     BIO_printf(bio_out, "%s:\n", name);
 378     if (drbg != NULL) {
 379         rand = EVP_RAND_CTX_rand(drbg);
 380
 381         BIO_printf(bio_out, "  %s", EVP_RAND_name(rand));
 382         BIO_printf(bio_out, " @ %s\n",
 383                    OSSL_PROVIDER_name(EVP_RAND_provider(rand)));
 384
 385         switch (EVP_RAND_state(drbg)) {
 386         case EVP_RAND_STATE_UNINITIALISED:
 387             p = "uninitialised";
 388             break;
 389         case EVP_RAND_STATE_READY:
 390             p = "ready";
 391             break;
 392         case EVP_RAND_STATE_ERROR:
 393             p = "error";
 394             break;
 395         default:
 396             p = "unknown";
 397             break;
 398         }
 399         BIO_printf(bio_out, "  state = %s\n", p);
 400
 401         gettables = EVP_RAND_gettable_ctx_params(rand);
 402         if (gettables != NULL)
 403             for (; gettables->key != NULL; gettables++) {
 404                 /* State has been dealt with already, so ignore */
 405                 if (strcasecmp(gettables->key, OSSL_RAND_PARAM_STATE) == 0)
 406                     continue;
 407                 /* Outside of verbose mode, we skip non-string values */
 408                 if (gettables->data_type != OSSL_PARAM_UTF8_STRING
 409                         && gettables->data_type != OSSL_PARAM_UTF8_PTR
 410                         && !verbose)
 411                     continue;
 412                 params->key = gettables->key;
 413                 params->data_type = gettables->data_type;
 414                 if (gettables->data_type == OSSL_PARAM_UNSIGNED_INTEGER
 415                         || gettables->data_type == OSSL_PARAM_INTEGER) {
 416                     params->data = &u;
 417                     params->data_size = sizeof(u);
 418                 } else {
 419                     params->data = buf;
 420                     params->data_size = sizeof(buf);
 421                 }
 422                 params->return_size = 0;
 423                 if (EVP_RAND_get_ctx_params(drbg, params))
 424                     print_param_value(params, 2);
 425             }
 426     }
 427 }
 428
 429 static void list_random_instances(void)
 430 {
 431     display_random("primary", RAND_get0_primary(NULL));
 432     display_random("public", RAND_get0_public(NULL));
 433     display_random("private", RAND_get0_private(NULL));
 434 }
 435
 436 /*
 437  * Encoders
 438  */
 439 DEFINE_STACK_OF(OSSL_ENCODER)
 440 static int encoder_cmp(const OSSL_ENCODER * const *a,
 441                        const OSSL_ENCODER * const *b)
 442 {
 443     int ret = OSSL_ENCODER_number(*a) - OSSL_ENCODER_number(*b);
 444
 445     if (ret == 0)
 446         ret = strcmp(OSSL_PROVIDER_name(OSSL_ENCODER_provider(*a)),
 447                      OSSL_PROVIDER_name(OSSL_ENCODER_provider(*b)));
 448     return ret;
 449 }
 450
 451 static void collect_encoders(OSSL_ENCODER *encoder, void *stack)
 452 {
 453     STACK_OF(OSSL_ENCODER) *encoder_stack = stack;
 454
 455     sk_OSSL_ENCODER_push(encoder_stack, encoder);
 456     OSSL_ENCODER_up_ref(encoder);
 457 }
 458
 459 static void list_encoders(void)
 460 {
 461     STACK_OF(OSSL_ENCODER) *encoders;
 462     int i;
 463
 464     encoders = sk_OSSL_ENCODER_new(encoder_cmp);
 465     if (encoders == NULL) {
 466         BIO_printf(bio_err, "ERROR: Memory allocation\n");
 467         return;
 468     }
 469     BIO_printf(bio_out, "Provided ENCODERs:\n");
 470     OSSL_ENCODER_do_all_provided(NULL, collect_encoders, encoders);
 471     sk_OSSL_ENCODER_sort(encoders);
 472
 473     for (i = 0; i < sk_OSSL_ENCODER_num(encoders); i++) {
 474         OSSL_ENCODER *k = sk_OSSL_ENCODER_value(encoders, i);
 475         STACK_OF(OPENSSL_CSTRING) *names = NULL;
 476
 477         if (select_name != NULL && !OSSL_ENCODER_is_a(k, select_name))
 478             continue;
 479
 480         names = sk_OPENSSL_CSTRING_new(name_cmp);
 481         OSSL_ENCODER_names_do_all(k, collect_names, names);
 482         BIO_printf(bio_out, "  ");
 483         print_names(bio_out, names);
 484         sk_OPENSSL_CSTRING_free(names);
 485
 486         BIO_printf(bio_out, " @ %s (%s)\n",
 487                    OSSL_PROVIDER_name(OSSL_ENCODER_provider(k)),
 488                    OSSL_ENCODER_properties(k));
 489
 490         if (verbose) {
 491             print_param_types("settable operation parameters",
 492                               OSSL_ENCODER_settable_ctx_params(k), 4);
 493         }
 494     }
 495     sk_OSSL_ENCODER_pop_free(encoders, OSSL_ENCODER_free);
 496 }
 497
 498 /*
 499  * Decoders
 500  */
 501 DEFINE_STACK_OF(OSSL_DECODER)
 502 static int decoder_cmp(const OSSL_DECODER * const *a,
 503                        const OSSL_DECODER * const *b)
 504 {
 505     int ret = OSSL_DECODER_number(*a) - OSSL_DECODER_number(*b);
 506
 507     if (ret == 0)
 508         ret = strcmp(OSSL_PROVIDER_name(OSSL_DECODER_provider(*a)),
 509                      OSSL_PROVIDER_name(OSSL_DECODER_provider(*b)));
 510     return ret;
 511 }
 512
 513 static void collect_decoders(OSSL_DECODER *decoder, void *stack)
 514 {
 515     STACK_OF(OSSL_DECODER) *decoder_stack = stack;
 516
 517     sk_OSSL_DECODER_push(decoder_stack, decoder);
 518     OSSL_DECODER_up_ref(decoder);
 519 }
 520
 521 static void list_decoders(void)
 522 {
 523     STACK_OF(OSSL_DECODER) *decoders;
 524     int i;
 525
 526     decoders = sk_OSSL_DECODER_new(decoder_cmp);
 527     if (decoders == NULL) {
 528         BIO_printf(bio_err, "ERROR: Memory allocation\n");
 529         return;
 530     }
 531     BIO_printf(bio_out, "Provided DECODERs:\n");
 532     OSSL_DECODER_do_all_provided(NULL, collect_decoders,
 533                                  decoders);
 534     sk_OSSL_DECODER_sort(decoders);
 535
 536     for (i = 0; i < sk_OSSL_DECODER_num(decoders); i++) {
 537         OSSL_DECODER *k = sk_OSSL_DECODER_value(decoders, i);
 538         STACK_OF(OPENSSL_CSTRING) *names = NULL;
 539
 540         if (select_name != NULL && !OSSL_DECODER_is_a(k, select_name))
 541             continue;
 542
 543         names = sk_OPENSSL_CSTRING_new(name_cmp);
 544         OSSL_DECODER_names_do_all(k, collect_names, names);
 545         BIO_printf(bio_out, "  ");
 546         print_names(bio_out, names);
 547         sk_OPENSSL_CSTRING_free(names);
 548
 549         BIO_printf(bio_out, " @ %s (%s)\n",
 550                    OSSL_PROVIDER_name(OSSL_DECODER_provider(k)),
 551                    OSSL_DECODER_properties(k));
 552
 553         if (verbose) {
 554             print_param_types("settable operation parameters",
 555                               OSSL_DECODER_settable_ctx_params(k), 4);
 556         }
 557     }
 558     sk_OSSL_DECODER_pop_free(decoders, OSSL_DECODER_free);
 559 }
 560
 561 DEFINE_STACK_OF(EVP_KEYMGMT)
 562 static int keymanager_cmp(const EVP_KEYMGMT * const *a,
 563                           const EVP_KEYMGMT * const *b)
 564 {
 565     int ret = EVP_KEYMGMT_number(*a) - EVP_KEYMGMT_number(*b);
 566
 567     if (ret == 0)
 568         ret = strcmp(OSSL_PROVIDER_name(EVP_KEYMGMT_provider(*a)),
 569                      OSSL_PROVIDER_name(EVP_KEYMGMT_provider(*b)));
 570     return ret;
 571 }
 572
 573 static void collect_keymanagers(EVP_KEYMGMT *km, void *stack)
 574 {
 575     STACK_OF(EVP_KEYMGMT) *km_stack = stack;
 576
 577     sk_EVP_KEYMGMT_push(km_stack, km);
 578     EVP_KEYMGMT_up_ref(km);
 579 }
 580
 581 static void list_keymanagers(void)
 582 {
 583     int i;
 584     STACK_OF(EVP_KEYMGMT) *km_stack = sk_EVP_KEYMGMT_new(keymanager_cmp);
 585
 586     EVP_KEYMGMT_do_all_provided(NULL, collect_keymanagers, km_stack);
 587     sk_EVP_KEYMGMT_sort(km_stack);
 588
 589     for (i = 0; i < sk_EVP_KEYMGMT_num(km_stack); i++) {
 590         EVP_KEYMGMT *k = sk_EVP_KEYMGMT_value(km_stack, i);
 591         STACK_OF(OPENSSL_CSTRING) *names = NULL;
 592
 593         if (select_name != NULL && !EVP_KEYMGMT_is_a(k, select_name))
 594             continue;
 595
 596         names = sk_OPENSSL_CSTRING_new(name_cmp);
 597         EVP_KEYMGMT_names_do_all(k, collect_names, names);
 598         BIO_printf(bio_out, "  ");
 599         print_names(bio_out, names);
 600         sk_OPENSSL_CSTRING_free(names);
 601
 602         BIO_printf(bio_out, " @ %s\n",
 603                    OSSL_PROVIDER_name(EVP_KEYMGMT_provider(k)));
 604
 605         if (verbose) {
 606             print_param_types("settable key generation parameters",
 607                               EVP_KEYMGMT_gen_settable_params(k), 4);
 608             print_param_types("settable operation parameters",
 609                               EVP_KEYMGMT_settable_params(k), 4);
 610             print_param_types("retrievable operation parameters",
 611                               EVP_KEYMGMT_gettable_params(k), 4);
 612         }
 613     }
 614     sk_EVP_KEYMGMT_pop_free(km_stack, EVP_KEYMGMT_free);
 615 }
 616
 617 DEFINE_STACK_OF(EVP_SIGNATURE)
 618 static int signature_cmp(const EVP_SIGNATURE * const *a,
 619                          const EVP_SIGNATURE * const *b)
 620 {
 621     int ret = EVP_SIGNATURE_number(*a) - EVP_SIGNATURE_number(*b);
 622
 623     if (ret == 0)
 624         ret = strcmp(OSSL_PROVIDER_name(EVP_SIGNATURE_provider(*a)),
 625                      OSSL_PROVIDER_name(EVP_SIGNATURE_provider(*b)));
 626     return ret;
 627 }
 628
 629 static void collect_signatures(EVP_SIGNATURE *km, void *stack)
 630 {
 631     STACK_OF(EVP_SIGNATURE) *km_stack = stack;
 632
 633     sk_EVP_SIGNATURE_push(km_stack, km);
 634     EVP_SIGNATURE_up_ref(km);
 635 }
 636
 637 static void list_signatures(void)
 638 {
 639     int i, count = 0;
 640     STACK_OF(EVP_SIGNATURE) *sig_stack = sk_EVP_SIGNATURE_new(signature_cmp);
 641
 642     EVP_SIGNATURE_do_all_provided(NULL, collect_signatures, sig_stack);
 643     sk_EVP_SIGNATURE_sort(sig_stack);
 644
 645     for (i = 0; i < sk_EVP_SIGNATURE_num(sig_stack); i++) {
 646         EVP_SIGNATURE *k = sk_EVP_SIGNATURE_value(sig_stack, i);
 647         STACK_OF(OPENSSL_CSTRING) *names = NULL;
 648
 649         if (select_name != NULL && !EVP_SIGNATURE_is_a(k, select_name))
 650             continue;
 651
 652         names = sk_OPENSSL_CSTRING_new(name_cmp);
 653         EVP_SIGNATURE_names_do_all(k, collect_names, names);
 654         count++;
 655         BIO_printf(bio_out, "  ");
 656         print_names(bio_out, names);
 657         sk_OPENSSL_CSTRING_free(names);
 658
 659         BIO_printf(bio_out, " @ %s\n",
 660                    OSSL_PROVIDER_name(EVP_SIGNATURE_provider(k)));
 661
 662         if (verbose) {
 663             print_param_types("settable operation parameters",
 664                               EVP_SIGNATURE_settable_ctx_params(k), 4);
 665             print_param_types("retrievable operation parameters",
 666                               EVP_SIGNATURE_gettable_ctx_params(k), 4);
 667         }
 668     }
 669     sk_EVP_SIGNATURE_pop_free(sig_stack, EVP_SIGNATURE_free);
 670     if (count == 0)
 671         BIO_printf(bio_out, " -\n");
 672 }
 673
 674 DEFINE_STACK_OF(EVP_KEM)
 675 static int kem_cmp(const EVP_KEM * const *a,
 676                    const EVP_KEM * const *b)
 677 {
 678     int ret = EVP_KEM_number(*a) - EVP_KEM_number(*b);
 679
 680     if (ret == 0)
 681         ret = strcmp(OSSL_PROVIDER_name(EVP_KEM_provider(*a)),
 682                      OSSL_PROVIDER_name(EVP_KEM_provider(*b)));
 683     return ret;
 684 }
 685
 686 static void collect_kem(EVP_KEM *km, void *stack)
 687 {
 688     STACK_OF(EVP_KEM) *km_stack = stack;
 689
 690     sk_EVP_KEM_push(km_stack, km);
 691     EVP_KEM_up_ref(km);
 692 }
 693
 694 static void list_kems(void)
 695 {
 696     int i, count = 0;
 697     STACK_OF(EVP_KEM) *kem_stack = sk_EVP_KEM_new(kem_cmp);
 698
 699     EVP_KEM_do_all_provided(NULL, collect_kem, kem_stack);
 700     sk_EVP_KEM_sort(kem_stack);
 701
 702     for (i = 0; i < sk_EVP_KEM_num(kem_stack); i++) {
 703         EVP_KEM *k = sk_EVP_KEM_value(kem_stack, i);
 704         STACK_OF(OPENSSL_CSTRING) *names = NULL;
 705
 706         if (select_name != NULL && !EVP_KEM_is_a(k, select_name))
 707             continue;
 708
 709         names = sk_OPENSSL_CSTRING_new(name_cmp);
 710         EVP_KEM_names_do_all(k, collect_names, names);
 711         count++;
 712         BIO_printf(bio_out, "  ");
 713         print_names(bio_out, names);
 714         sk_OPENSSL_CSTRING_free(names);
 715
 716         BIO_printf(bio_out, " @ %s\n", OSSL_PROVIDER_name(EVP_KEM_provider(k)));
 717
 718         if (verbose) {
 719             print_param_types("settable operation parameters",
 720                               EVP_KEM_settable_ctx_params(k), 4);
 721             print_param_types("retrievable operation parameters",
 722                               EVP_KEM_gettable_ctx_params(k), 4);
 723         }
 724     }
 725     sk_EVP_KEM_pop_free(kem_stack, EVP_KEM_free);
 726     if (count == 0)
 727         BIO_printf(bio_out, " -\n");
 728 }
 729
 730 DEFINE_STACK_OF(EVP_ASYM_CIPHER)
 731 static int asymcipher_cmp(const EVP_ASYM_CIPHER * const *a,
 732                           const EVP_ASYM_CIPHER * const *b)
 733 {
 734     int ret = EVP_ASYM_CIPHER_number(*a) - EVP_ASYM_CIPHER_number(*b);
 735
 736     if (ret == 0)
 737         ret = strcmp(OSSL_PROVIDER_name(EVP_ASYM_CIPHER_provider(*a)),
 738                      OSSL_PROVIDER_name(EVP_ASYM_CIPHER_provider(*b)));
 739     return ret;
 740 }
 741
 742 static void collect_asymciph(EVP_ASYM_CIPHER *km, void *stack)
 743 {
 744     STACK_OF(EVP_ASYM_CIPHER) *km_stack = stack;
 745
 746     sk_EVP_ASYM_CIPHER_push(km_stack, km);
 747     EVP_ASYM_CIPHER_up_ref(km);
 748 }
 749
 750 static void list_asymciphers(void)
 751 {
 752     int i, count = 0;
 753     STACK_OF(EVP_ASYM_CIPHER) *asymciph_stack =
 754         sk_EVP_ASYM_CIPHER_new(asymcipher_cmp);
 755
 756     EVP_ASYM_CIPHER_do_all_provided(NULL, collect_asymciph, asymciph_stack);
 757     sk_EVP_ASYM_CIPHER_sort(asymciph_stack);
 758
 759     for (i = 0; i < sk_EVP_ASYM_CIPHER_num(asymciph_stack); i++) {
 760         EVP_ASYM_CIPHER *k = sk_EVP_ASYM_CIPHER_value(asymciph_stack, i);
 761         STACK_OF(OPENSSL_CSTRING) *names = NULL;
 762
 763         if (select_name != NULL && !EVP_ASYM_CIPHER_is_a(k, select_name))
 764             continue;
 765
 766         names = sk_OPENSSL_CSTRING_new(name_cmp);
 767         EVP_ASYM_CIPHER_names_do_all(k, collect_names, names);
 768         count++;
 769         BIO_printf(bio_out, "  ");
 770         print_names(bio_out, names);
 771         sk_OPENSSL_CSTRING_free(names);
 772
 773         BIO_printf(bio_out, " @ %s\n",
 774                    OSSL_PROVIDER_name(EVP_ASYM_CIPHER_provider(k)));
 775
 776         if (verbose) {
 777             print_param_types("settable operation parameters",
 778                               EVP_ASYM_CIPHER_settable_ctx_params(k), 4);
 779             print_param_types("retrievable operation parameters",
 780                               EVP_ASYM_CIPHER_gettable_ctx_params(k), 4);
 781         }
 782     }
 783     sk_EVP_ASYM_CIPHER_pop_free(asymciph_stack, EVP_ASYM_CIPHER_free);
 784     if (count == 0)
 785         BIO_printf(bio_out, " -\n");
 786 }
 787
 788 DEFINE_STACK_OF(EVP_KEYEXCH)
 789 static int kex_cmp(const EVP_KEYEXCH * const *a,
 790                    const EVP_KEYEXCH * const *b)
 791 {
 792     int ret = EVP_KEYEXCH_number(*a) - EVP_KEYEXCH_number(*b);
 793
 794     if (ret == 0)
 795         ret = strcmp(OSSL_PROVIDER_name(EVP_KEYEXCH_provider(*a)),
 796                      OSSL_PROVIDER_name(EVP_KEYEXCH_provider(*b)));
 797     return ret;
 798 }
 799
 800 static void collect_kex(EVP_KEYEXCH *ke, void *stack)
 801 {
 802     STACK_OF(EVP_KEYEXCH) *kex_stack = stack;
 803
 804     sk_EVP_KEYEXCH_push(kex_stack, ke);
 805     EVP_KEYEXCH_up_ref(ke);
 806 }
 807
 808 static void list_keyexchanges(void)
 809 {
 810     int i, count = 0;
 811     STACK_OF(EVP_KEYEXCH) *kex_stack = sk_EVP_KEYEXCH_new(kex_cmp);
 812
 813     EVP_KEYEXCH_do_all_provided(NULL, collect_kex, kex_stack);
 814     sk_EVP_KEYEXCH_sort(kex_stack);
 815
 816     for (i = 0; i < sk_EVP_KEYEXCH_num(kex_stack); i++) {
 817         EVP_KEYEXCH *k = sk_EVP_KEYEXCH_value(kex_stack, i);
 818         STACK_OF(OPENSSL_CSTRING) *names = NULL;
 819
 820         if (select_name != NULL && !EVP_KEYEXCH_is_a(k, select_name))
 821             continue;
 822
 823         names = sk_OPENSSL_CSTRING_new(name_cmp);
 824         EVP_KEYEXCH_names_do_all(k, collect_names, names);
 825         count++;
 826         BIO_printf(bio_out, "  ");
 827         print_names(bio_out, names);
 828         sk_OPENSSL_CSTRING_free(names);
 829
 830         BIO_printf(bio_out, " @ %s\n",
 831                    OSSL_PROVIDER_name(EVP_KEYEXCH_provider(k)));
 832
 833         if (verbose) {
 834             print_param_types("settable operation parameters",
 835                               EVP_KEYEXCH_settable_ctx_params(k), 4);
 836             print_param_types("retrievable operation parameters",
 837                               EVP_KEYEXCH_gettable_ctx_params(k), 4);
 838         }
 839     }
 840     sk_EVP_KEYEXCH_pop_free(kex_stack, EVP_KEYEXCH_free);
 841     if (count == 0)
 842         BIO_printf(bio_out, " -\n");
 843 }
 844
 845 static void list_missing_help(void)
 846 {
 847     const FUNCTION *fp;
 848     const OPTIONS *o;
 849
 850     for (fp = functions; fp->name != NULL; fp++) {
 851         if ((o = fp->help) != NULL) {
 852             /* If there is help, list what flags are not documented. */
 853             for ( ; o->name != NULL; o++) {
 854                 if (o->helpstr == NULL)
 855                     BIO_printf(bio_out, "%s %s\n", fp->name, o->name);
 856             }
 857         } else if (fp->func != dgst_main) {
 858             /* If not aliased to the dgst command, */
 859             BIO_printf(bio_out, "%s *\n", fp->name);
 860         }
 861     }
 862 }
 863
 864 static void list_objects(void)
 865 {
 866     int max_nid = OBJ_new_nid(0);
 867     int i;
 868     char *oid_buf = NULL;
 869     int oid_size = 0;
 870
 871     /* Skip 0, since that's NID_undef */
 872     for (i = 1; i < max_nid; i++) {
 873         const ASN1_OBJECT *obj = OBJ_nid2obj(i);
 874         const char *sn = OBJ_nid2sn(i);
 875         const char *ln = OBJ_nid2ln(i);
 876         int n = 0;
 877
 878         /*
 879          * If one of the retrieved objects somehow generated an error,
 880          * we ignore it.  The check for NID_undef below will detect the
 881          * error and simply skip to the next NID.
 882          */
 883         ERR_clear_error();
 884
 885         if (OBJ_obj2nid(obj) == NID_undef)
 886             continue;
 887
 888         if ((n = OBJ_obj2txt(NULL, 0, obj, 1)) == 0) {
 889             BIO_printf(bio_out, "# None-OID object: %s, %s\n", sn, ln);
 890             continue;
 891         }
 892         if (n < 0)
 893             break;               /* Error */
 894
 895         if (n > oid_size) {
 896             oid_buf = OPENSSL_realloc(oid_buf, n + 1);
 897             if (oid_buf == NULL) {
 898                 BIO_printf(bio_err, "ERROR: Memory allocation\n");
 899                 break;           /* Error */
 900             }
 901             oid_size = n + 1;
 902         }
 903         if (OBJ_obj2txt(oid_buf, oid_size, obj, 1) < 0)
 904             break;               /* Error */
 905         if (ln == NULL || strcmp(sn, ln) == 0)
 906             BIO_printf(bio_out, "%s = %s\n", sn, oid_buf);
 907         else
 908             BIO_printf(bio_out, "%s = %s, %s\n", sn, ln, oid_buf);
 909     }
 910
 911     OPENSSL_free(oid_buf);
 912 }
 913
 914 static void list_options_for_command(const char *command)
 915 {
 916     const FUNCTION *fp;
 917     const OPTIONS *o;
 918
 919     for (fp = functions; fp->name != NULL; fp++)
 920         if (strcmp(fp->name, command) == 0)
 921             break;
 922     if (fp->name == NULL) {
 923         BIO_printf(bio_err, "Invalid command '%s'; type \"help\" for a list.\n",
 924                    command);
 925         return;
 926     }
 927
 928     if ((o = fp->help) == NULL)
 929         return;
 930
 931     for ( ; o->name != NULL; o++) {
 932         char c = o->valtype;
 933
 934         if (o->name == OPT_PARAM_STR)
 935             break;
 936
 937         if (o->name == OPT_HELP_STR
 938                 || o->name == OPT_MORE_STR
 939                 || o->name == OPT_SECTION_STR
 940                 || o->name[0] == '\0')
 941             continue;
 942         BIO_printf(bio_out, "%s %c\n", o->name, c == '\0' ? '-' : c);
 943     }
 944     /* Always output the -- marker since it is sometimes documented. */
 945     BIO_printf(bio_out, "- -\n");
 946 }
 947
 948 static int is_md_available(const char *name)
 949 {
 950     EVP_MD *md;
 951
 952     /* Look through providers' digests */
 953     ERR_set_mark();
 954     md = EVP_MD_fetch(NULL, name, NULL);
 955     ERR_pop_to_mark();
 956     if (md != NULL) {
 957         EVP_MD_free(md);
 958         return 1;
 959     }
 960
 961     return (get_digest_from_engine(name) == NULL) ? 0 : 1;
 962 }
 963
 964 static int is_cipher_available(const char *name)
 965 {
 966     EVP_CIPHER *cipher;
 967
 968     /* Look through providers' ciphers */
 969     ERR_set_mark();
 970     cipher = EVP_CIPHER_fetch(NULL, name, NULL);
 971     ERR_pop_to_mark();
 972     if (cipher != NULL) {
 973         EVP_CIPHER_free(cipher);
 974         return 1;
 975     }
 976
 977     return (get_cipher_from_engine(name) == NULL) ? 0 : 1;
 978 }
 979
 980 static void list_type(FUNC_TYPE ft, int one)
 981 {
 982     FUNCTION *fp;
 983     int i = 0;
 984     DISPLAY_COLUMNS dc;
 985
 986     memset(&dc, 0, sizeof(dc));
 987     if (!one)
 988         calculate_columns(functions, &dc);
 989
 990     for (fp = functions; fp->name != NULL; fp++) {
 991         if (fp->type != ft)
 992             continue;
 993         switch (ft) {
 994         case FT_cipher:
 995             if (!is_cipher_available(fp->name))
 996                 continue;
 997             break;
 998         case FT_md:
 999             if (!is_md_available(fp->name))
1000                 continue;
1001             break;
1002         default:
1003             break;
1004         }
1005         if (one) {
1006             BIO_printf(bio_out, "%s\n", fp->name);
1007         } else {
1008             if (i % dc.columns == 0 && i > 0)
1009                 BIO_printf(bio_out, "\n");
1010             BIO_printf(bio_out, "%-*s", dc.width, fp->name);
1011             i++;
1012         }
1013     }
1014     if (!one)
1015         BIO_printf(bio_out, "\n\n");
1016 }
1017
1018 static void list_pkey(void)
1019 {
1020 #ifndef OPENSSL_NO_DEPRECATED_3_0
1021     int i;
1022
1023     if (select_name == NULL) {
1024         BIO_printf(bio_out, "Legacy:\n");
1025         for (i = 0; i < EVP_PKEY_asn1_get_count(); i++) {
1026             const EVP_PKEY_ASN1_METHOD *ameth;
1027             int pkey_id, pkey_base_id, pkey_flags;
1028             const char *pinfo, *pem_str;
1029             ameth = EVP_PKEY_asn1_get0(i);
1030             EVP_PKEY_asn1_get0_info(&pkey_id, &pkey_base_id, &pkey_flags,
1031                                     &pinfo, &pem_str, ameth);
1032             if (pkey_flags & ASN1_PKEY_ALIAS) {
1033                 BIO_printf(bio_out, " Name: %s\n", OBJ_nid2ln(pkey_id));
1034                 BIO_printf(bio_out, "\tAlias for: %s\n",
1035                            OBJ_nid2ln(pkey_base_id));
1036             } else {
1037                 BIO_printf(bio_out, " Name: %s\n", pinfo);
1038                 BIO_printf(bio_out, "\tType: %s Algorithm\n",
1039                            pkey_flags & ASN1_PKEY_DYNAMIC ?
1040                            "External" : "Builtin");
1041                 BIO_printf(bio_out, "\tOID: %s\n", OBJ_nid2ln(pkey_id));
1042                 if (pem_str == NULL)
1043                     pem_str = "(none)";
1044                 BIO_printf(bio_out, "\tPEM string: %s\n", pem_str);
1045             }
1046         }
1047     }
1048 #endif
1049     BIO_printf(bio_out, "Provided:\n");
1050     BIO_printf(bio_out, " Key Managers:\n");
1051     list_keymanagers();
1052 }
1053
1054 static void list_pkey_meth(void)
1055 {
1056 #ifndef OPENSSL_NO_DEPRECATED_3_0
1057     size_t i;
1058     size_t meth_count = EVP_PKEY_meth_get_count();
1059
1060     if (select_name == NULL) {
1061         BIO_printf(bio_out, "Legacy:\n");
1062         for (i = 0; i < meth_count; i++) {
1063             const EVP_PKEY_METHOD *pmeth = EVP_PKEY_meth_get0(i);
1064             int pkey_id, pkey_flags;
1065
1066             EVP_PKEY_meth_get0_info(&pkey_id, &pkey_flags, pmeth);
1067             BIO_printf(bio_out, " %s\n", OBJ_nid2ln(pkey_id));
1068             BIO_printf(bio_out, "\tType: %s Algorithm\n",
1069                        pkey_flags & ASN1_PKEY_DYNAMIC ?  "External" : "Builtin");
1070         }
1071     }
1072 #endif
1073     BIO_printf(bio_out, "Provided:\n");
1074     BIO_printf(bio_out, " Encryption:\n");
1075     list_asymciphers();
1076     BIO_printf(bio_out, " Key Exchange:\n");
1077     list_keyexchanges();
1078     BIO_printf(bio_out, " Signatures:\n");
1079     list_signatures();
1080     BIO_printf(bio_out, " Key encapsulation:\n");
1081     list_kems();
1082 }
1083
1084 DEFINE_STACK_OF(OSSL_PROVIDER)
1085 static int provider_cmp(const OSSL_PROVIDER * const *a,
1086                         const OSSL_PROVIDER * const *b)
1087 {
1088     return strcmp(OSSL_PROVIDER_name(*a), OSSL_PROVIDER_name(*b));
1089 }
1090
1091 static int collect_providers(OSSL_PROVIDER *provider, void *stack)
1092 {
1093     STACK_OF(OSSL_PROVIDER) *provider_stack = stack;
1094
1095     sk_OSSL_PROVIDER_push(provider_stack, provider);
1096     return 1;
1097 }
1098
1099 static void list_provider_info(void)
1100 {
1101     STACK_OF(OSSL_PROVIDER) *providers = sk_OSSL_PROVIDER_new(provider_cmp);
1102     OSSL_PARAM params[5];
1103     char *name, *version, *buildinfo;
1104     int status;
1105     int i;
1106
1107     if (providers == NULL) {
1108         BIO_printf(bio_err, "ERROR: Memory allocation\n");
1109         return;
1110     }
1111     BIO_printf(bio_out, "Providers:\n");
1112     OSSL_PROVIDER_do_all(NULL, &collect_providers, providers);
1113     sk_OSSL_PROVIDER_sort(providers);
1114     for (i = 0; i < sk_OSSL_PROVIDER_num(providers); i++) {
1115         const OSSL_PROVIDER *prov = sk_OSSL_PROVIDER_value(providers, i);
1116
1117         /* Query the "known" information parameters, the order matches below */
1118         params[0] = OSSL_PARAM_construct_utf8_ptr(OSSL_PROV_PARAM_NAME,
1119                                                   &name, 0);
1120         params[1] = OSSL_PARAM_construct_utf8_ptr(OSSL_PROV_PARAM_VERSION,
1121                                                   &version, 0);
1122         params[2] = OSSL_PARAM_construct_int(OSSL_PROV_PARAM_STATUS, &status);
1123         params[3] = OSSL_PARAM_construct_utf8_ptr(OSSL_PROV_PARAM_BUILDINFO,
1124                                                   &buildinfo, 0);
1125         params[4] = OSSL_PARAM_construct_end();
1126         OSSL_PARAM_set_all_unmodified(params);
1127         if (!OSSL_PROVIDER_get_params(prov, params)) {
1128             BIO_printf(bio_err, "ERROR: Unable to query provider parameters\n");
1129             return;
1130         }
1131
1132         /* Print out the provider information, the params order matches above */
1133         BIO_printf(bio_out, "  %s\n", OSSL_PROVIDER_name(prov));
1134         if (OSSL_PARAM_modified(params))
1135             BIO_printf(bio_out, "    name: %s\n", name);
1136         if (OSSL_PARAM_modified(params + 1))
1137             BIO_printf(bio_out, "    version: %s\n", version);
1138         if (OSSL_PARAM_modified(params + 2))
1139             BIO_printf(bio_out, "    status: %sactive\n", status ? "" : "in");
1140         if (verbose) {
1141             if (OSSL_PARAM_modified(params + 3))
1142                 BIO_printf(bio_out, "    build info: %s\n", buildinfo);
1143             print_param_types("gettable provider parameters",
1144                               OSSL_PROVIDER_gettable_params(prov), 4);
1145         }
1146     }
1147     sk_OSSL_PROVIDER_free(providers);
1148 }
1149
1150 #ifndef OPENSSL_NO_DEPRECATED_3_0
1151 static void list_engines(void)
1152 {
1153 # ifndef OPENSSL_NO_ENGINE
1154     ENGINE *e;
1155
1156     BIO_puts(bio_out, "Engines:\n");
1157     e = ENGINE_get_first();
1158     while (e) {
1159         BIO_printf(bio_out, "%s\n", ENGINE_get_id(e));
1160         e = ENGINE_get_next(e);
1161     }
1162 # else
1163     BIO_puts(bio_out, "Engine support is disabled.\n");
1164 # endif
1165 }
1166 #endif
1167
1168 static void list_disabled(void)
1169 {
1170     BIO_puts(bio_out, "Disabled algorithms:\n");
1171 #ifdef OPENSSL_NO_ARIA
1172     BIO_puts(bio_out, "ARIA\n");
1173 #endif
1174 #ifdef OPENSSL_NO_BF
1175     BIO_puts(bio_out, "BF\n");
1176 #endif
1177 #ifdef OPENSSL_NO_BLAKE2
1178     BIO_puts(bio_out, "BLAKE2\n");
1179 #endif
1180 #ifdef OPENSSL_NO_CAMELLIA
1181     BIO_puts(bio_out, "CAMELLIA\n");
1182 #endif
1183 #ifdef OPENSSL_NO_CAST
1184     BIO_puts(bio_out, "CAST\n");
1185 #endif
1186 #ifdef OPENSSL_NO_CMAC
1187     BIO_puts(bio_out, "CMAC\n");
1188 #endif
1189 #ifdef OPENSSL_NO_CMS
1190     BIO_puts(bio_out, "CMS\n");
1191 #endif
1192 #ifdef OPENSSL_NO_COMP
1193     BIO_puts(bio_out, "COMP\n");
1194 #endif
1195 #ifdef OPENSSL_NO_DES
1196     BIO_puts(bio_out, "DES\n");
1197 #endif
1198 #ifdef OPENSSL_NO_DGRAM
1199     BIO_puts(bio_out, "DGRAM\n");
1200 #endif
1201 #ifdef OPENSSL_NO_DH
1202     BIO_puts(bio_out, "DH\n");
1203 #endif
1204 #ifdef OPENSSL_NO_DSA
1205     BIO_puts(bio_out, "DSA\n");
1206 #endif
1207 #if defined(OPENSSL_NO_DTLS)
1208     BIO_puts(bio_out, "DTLS\n");
1209 #endif
1210 #if defined(OPENSSL_NO_DTLS1)
1211     BIO_puts(bio_out, "DTLS1\n");
1212 #endif
1213 #if defined(OPENSSL_NO_DTLS1_2)
1214     BIO_puts(bio_out, "DTLS1_2\n");
1215 #endif
1216 #ifdef OPENSSL_NO_EC
1217     BIO_puts(bio_out, "EC\n");
1218 #endif
1219 #ifdef OPENSSL_NO_EC2M
1220     BIO_puts(bio_out, "EC2M\n");
1221 #endif
1222 #if defined(OPENSSL_NO_ENGINE) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1223     BIO_puts(bio_out, "ENGINE\n");
1224 #endif
1225 #ifdef OPENSSL_NO_GOST
1226     BIO_puts(bio_out, "GOST\n");
1227 #endif
1228 #ifdef OPENSSL_NO_IDEA
1229     BIO_puts(bio_out, "IDEA\n");
1230 #endif
1231 #ifdef OPENSSL_NO_MD2
1232     BIO_puts(bio_out, "MD2\n");
1233 #endif
1234 #ifdef OPENSSL_NO_MD4
1235     BIO_puts(bio_out, "MD4\n");
1236 #endif
1237 #ifdef OPENSSL_NO_MD5
1238     BIO_puts(bio_out, "MD5\n");
1239 #endif
1240 #ifdef OPENSSL_NO_MDC2
1241     BIO_puts(bio_out, "MDC2\n");
1242 #endif
1243 #ifdef OPENSSL_NO_OCB
1244     BIO_puts(bio_out, "OCB\n");
1245 #endif
1246 #ifdef OPENSSL_NO_OCSP
1247     BIO_puts(bio_out, "OCSP\n");
1248 #endif
1249 #ifdef OPENSSL_NO_PSK
1250     BIO_puts(bio_out, "PSK\n");
1251 #endif
1252 #ifdef OPENSSL_NO_RC2
1253     BIO_puts(bio_out, "RC2\n");
1254 #endif
1255 #ifdef OPENSSL_NO_RC4
1256     BIO_puts(bio_out, "RC4\n");
1257 #endif
1258 #ifdef OPENSSL_NO_RC5
1259     BIO_puts(bio_out, "RC5\n");
1260 #endif
1261 #ifdef OPENSSL_NO_RMD160
1262     BIO_puts(bio_out, "RMD160\n");
1263 #endif
1264 #ifdef OPENSSL_NO_RSA
1265     BIO_puts(bio_out, "RSA\n");
1266 #endif
1267 #ifdef OPENSSL_NO_SCRYPT
1268     BIO_puts(bio_out, "SCRYPT\n");
1269 #endif
1270 #ifdef OPENSSL_NO_SCTP
1271     BIO_puts(bio_out, "SCTP\n");
1272 #endif
1273 #ifdef OPENSSL_NO_SEED
1274     BIO_puts(bio_out, "SEED\n");
1275 #endif
1276 #ifdef OPENSSL_NO_SM2
1277     BIO_puts(bio_out, "SM2\n");
1278 #endif
1279 #ifdef OPENSSL_NO_SM3
1280     BIO_puts(bio_out, "SM3\n");
1281 #endif
1282 #ifdef OPENSSL_NO_SM4
1283     BIO_puts(bio_out, "SM4\n");
1284 #endif
1285 #ifdef OPENSSL_NO_SOCK
1286     BIO_puts(bio_out, "SOCK\n");
1287 #endif
1288 #ifdef OPENSSL_NO_SRP
1289     BIO_puts(bio_out, "SRP\n");
1290 #endif
1291 #ifdef OPENSSL_NO_SRTP
1292     BIO_puts(bio_out, "SRTP\n");
1293 #endif
1294 #ifdef OPENSSL_NO_SSL3
1295     BIO_puts(bio_out, "SSL3\n");
1296 #endif
1297 #ifdef OPENSSL_NO_TLS1
1298     BIO_puts(bio_out, "TLS1\n");
1299 #endif
1300 #ifdef OPENSSL_NO_TLS1_1
1301     BIO_puts(bio_out, "TLS1_1\n");
1302 #endif
1303 #ifdef OPENSSL_NO_TLS1_2
1304     BIO_puts(bio_out, "TLS1_2\n");
1305 #endif
1306 #ifdef OPENSSL_NO_WHIRLPOOL
1307     BIO_puts(bio_out, "WHIRLPOOL\n");
1308 #endif
1309 #ifndef ZLIB
1310     BIO_puts(bio_out, "ZLIB\n");
1311 #endif
1312 }
1313
1314 /* Unified enum for help and list commands. */
1315 typedef enum HELPLIST_CHOICE {
1316     OPT_ERR = -1, OPT_EOF = 0, OPT_HELP, OPT_ONE, OPT_VERBOSE,
1317     OPT_COMMANDS, OPT_DIGEST_COMMANDS, OPT_MAC_ALGORITHMS, OPT_OPTIONS,
1318     OPT_DIGEST_ALGORITHMS, OPT_CIPHER_COMMANDS, OPT_CIPHER_ALGORITHMS,
1319     OPT_PK_ALGORITHMS, OPT_PK_METHOD, OPT_DISABLED,
1320     OPT_KDF_ALGORITHMS, OPT_RANDOM_INSTANCES, OPT_RANDOM_GENERATORS,
1321     OPT_ENCODERS, OPT_DECODERS, OPT_KEYMANAGERS, OPT_KEYEXCHANGE_ALGORITHMS,
1322     OPT_KEM_ALGORITHMS, OPT_SIGNATURE_ALGORITHMS, OPT_ASYM_CIPHER_ALGORITHMS,
1323     OPT_PROVIDER_INFO,
1324     OPT_MISSING_HELP, OPT_OBJECTS, OPT_SELECT_NAME,
1325 #ifndef OPENSSL_NO_DEPRECATED_3_0
1326     OPT_ENGINES,
1327 #endif
1328     OPT_PROV_ENUM
1329 } HELPLIST_CHOICE;
1330
1331 const OPTIONS list_options[] = {
1332
1333     OPT_SECTION("General"),
1334     {"help", OPT_HELP, '-', "Display this summary"},
1335
1336     OPT_SECTION("Output"),
1337     {"1", OPT_ONE, '-', "List in one column"},
1338     {"verbose", OPT_VERBOSE, '-', "Verbose listing"},
1339     {"select", OPT_SELECT_NAME, 's', "Select a single algorithm"},
1340     {"commands", OPT_COMMANDS, '-', "List of standard commands"},
1341     {"standard-commands", OPT_COMMANDS, '-', "List of standard commands"},
1342 #ifndef OPENSSL_NO_DEPRECATED_3_0
1343     {"digest-commands", OPT_DIGEST_COMMANDS, '-',
1344      "List of message digest commands (deprecated)"},
1345 #endif
1346     {"digest-algorithms", OPT_DIGEST_ALGORITHMS, '-',
1347      "List of message digest algorithms"},
1348     {"kdf-algorithms", OPT_KDF_ALGORITHMS, '-',
1349      "List of key derivation and pseudo random function algorithms"},
1350     {"random-instances", OPT_RANDOM_INSTANCES, '-',
1351      "List the primary, pubic and private random number generator details"},
1352     {"random-generators", OPT_RANDOM_GENERATORS, '-',
1353      "List of random number generators"},
1354     {"mac-algorithms", OPT_MAC_ALGORITHMS, '-',
1355      "List of message authentication code algorithms"},
1356 #ifndef OPENSSL_NO_DEPRECATED_3_0
1357     {"cipher-commands", OPT_CIPHER_COMMANDS, '-',
1358     "List of cipher commands (deprecated)"},
1359 #endif
1360     {"cipher-algorithms", OPT_CIPHER_ALGORITHMS, '-',
1361      "List of cipher algorithms"},
1362     {"encoders", OPT_ENCODERS, '-', "List of encoding methods" },
1363     {"decoders", OPT_DECODERS, '-', "List of decoding methods" },
1364     {"key-managers", OPT_KEYMANAGERS, '-', "List of key managers" },
1365     {"key-exchange-algorithms", OPT_KEYEXCHANGE_ALGORITHMS, '-',
1366      "List of key exchange algorithms" },
1367     {"kem-algorithms", OPT_KEM_ALGORITHMS, '-',
1368      "List of key encapsulation mechanism algorithms" },
1369     {"signature-algorithms", OPT_SIGNATURE_ALGORITHMS, '-',
1370      "List of signature algorithms" },
1371     { "asymcipher-algorithms", OPT_ASYM_CIPHER_ALGORITHMS, '-',
1372       "List of asymmetric cipher algorithms" },
1373     {"public-key-algorithms", OPT_PK_ALGORITHMS, '-',
1374      "List of public key algorithms"},
1375     {"public-key-methods", OPT_PK_METHOD, '-',
1376      "List of public key methods"},
1377     {"providers", OPT_PROVIDER_INFO, '-',
1378      "List of provider information"},
1379 #ifndef OPENSSL_NO_DEPRECATED_3_0
1380     {"engines", OPT_ENGINES, '-',
1381      "List of loaded engines"},
1382 #endif
1383     {"disabled", OPT_DISABLED, '-', "List of disabled features"},
1384     {"missing-help", OPT_MISSING_HELP, '-',
1385      "List missing detailed help strings"},
1386     {"options", OPT_OPTIONS, 's',
1387      "List options for specified command"},
1388     {"objects", OPT_OBJECTS, '-',
1389      "List built in objects (OID<->name mappings)"},
1390
1391     OPT_PROV_OPTIONS,
1392     {NULL}
1393 };
1394
1395 int list_main(int argc, char **argv)
1396 {
1397     char *prog;
1398     HELPLIST_CHOICE o;
1399     int one = 0, done = 0;
1400     struct {
1401         unsigned int commands:1;
1402         unsigned int random_instances:1;
1403         unsigned int random_generators:1;
1404         unsigned int digest_commands:1;
1405         unsigned int digest_algorithms:1;
1406         unsigned int kdf_algorithms:1;
1407         unsigned int mac_algorithms:1;
1408         unsigned int cipher_commands:1;
1409         unsigned int cipher_algorithms:1;
1410         unsigned int encoder_algorithms:1;
1411         unsigned int decoder_algorithms:1;
1412         unsigned int keymanager_algorithms:1;
1413         unsigned int signature_algorithms:1;
1414         unsigned int keyexchange_algorithms:1;
1415         unsigned int kem_algorithms:1;
1416         unsigned int asym_cipher_algorithms:1;
1417         unsigned int pk_algorithms:1;
1418         unsigned int pk_method:1;
1419         unsigned int provider_info:1;
1420 #ifndef OPENSSL_NO_DEPRECATED_3_0
1421         unsigned int engines:1;
1422 #endif
1423         unsigned int disabled:1;
1424         unsigned int missing_help:1;
1425         unsigned int objects:1;
1426         unsigned int options:1;
1427     } todo = { 0, };
1428
1429     verbose = 0;                 /* Clear a possible previous call */
1430
1431     prog = opt_init(argc, argv, list_options);
1432     while ((o = opt_next()) != OPT_EOF) {
1433         switch (o) {
1434         case OPT_EOF:  /* Never hit, but suppresses warning */
1435         case OPT_ERR:
1436 opthelp:
1437             BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1438             return 1;
1439         case OPT_HELP:
1440             opt_help(list_options);
1441             break;
1442         case OPT_ONE:
1443             one = 1;
1444             break;
1445         case OPT_COMMANDS:
1446             todo.commands = 1;
1447             break;
1448         case OPT_DIGEST_COMMANDS:
1449             todo.digest_commands = 1;
1450             break;
1451         case OPT_DIGEST_ALGORITHMS:
1452             todo.digest_algorithms = 1;
1453             break;
1454         case OPT_KDF_ALGORITHMS:
1455             todo.kdf_algorithms = 1;
1456             break;
1457         case OPT_RANDOM_INSTANCES:
1458             todo.random_instances = 1;
1459             break;
1460         case OPT_RANDOM_GENERATORS:
1461             todo.random_generators = 1;
1462             break;
1463         case OPT_MAC_ALGORITHMS:
1464             todo.mac_algorithms = 1;
1465             break;
1466         case OPT_CIPHER_COMMANDS:
1467             todo.cipher_commands = 1;
1468             break;
1469         case OPT_CIPHER_ALGORITHMS:
1470             todo.cipher_algorithms = 1;
1471             break;
1472         case OPT_ENCODERS:
1473             todo.encoder_algorithms = 1;
1474             break;
1475         case OPT_DECODERS:
1476             todo.decoder_algorithms = 1;
1477             break;
1478         case OPT_KEYMANAGERS:
1479             todo.keymanager_algorithms = 1;
1480             break;
1481         case OPT_SIGNATURE_ALGORITHMS:
1482             todo.signature_algorithms = 1;
1483             break;
1484         case OPT_KEYEXCHANGE_ALGORITHMS:
1485             todo.keyexchange_algorithms = 1;
1486             break;
1487         case OPT_KEM_ALGORITHMS:
1488             todo.kem_algorithms = 1;
1489             break;
1490         case OPT_ASYM_CIPHER_ALGORITHMS:
1491             todo.asym_cipher_algorithms = 1;
1492             break;
1493         case OPT_PK_ALGORITHMS:
1494             todo.pk_algorithms = 1;
1495             break;
1496         case OPT_PK_METHOD:
1497             todo.pk_method = 1;
1498             break;
1499         case OPT_PROVIDER_INFO:
1500             todo.provider_info = 1;
1501             break;
1502 #ifndef OPENSSL_NO_DEPRECATED_3_0
1503         case OPT_ENGINES:
1504             todo.engines = 1;
1505             break;
1506 #endif
1507         case OPT_DISABLED:
1508             todo.disabled = 1;
1509             break;
1510         case OPT_MISSING_HELP:
1511             todo.missing_help = 1;
1512             break;
1513         case OPT_OBJECTS:
1514             todo.objects = 1;
1515             break;
1516         case OPT_OPTIONS:
1517             list_options_for_command(opt_arg());
1518             break;
1519         case OPT_VERBOSE:
1520             verbose = 1;
1521             break;
1522         case OPT_SELECT_NAME:
1523             select_name = opt_arg();
1524             break;
1525         case OPT_PROV_CASES:
1526             if (!opt_provider(o))
1527                 return 1;
1528             break;
1529         }
1530         done = 1;
1531     }
1532     if (opt_num_rest() != 0) {
1533         BIO_printf(bio_err, "Extra arguments given.\n");
1534         goto opthelp;
1535     }
1536
1537     if (todo.commands)
1538         list_type(FT_general, one);
1539     if (todo.random_instances)
1540         list_random_instances();
1541     if (todo.random_generators)
1542         list_random_generators();
1543     if (todo.digest_commands)
1544         list_type(FT_md, one);
1545     if (todo.digest_algorithms)
1546         list_digests();
1547     if (todo.kdf_algorithms)
1548         list_kdfs();
1549     if (todo.mac_algorithms)
1550         list_macs();
1551     if (todo.cipher_commands)
1552         list_type(FT_cipher, one);
1553     if (todo.cipher_algorithms)
1554         list_ciphers();
1555     if (todo.encoder_algorithms)
1556         list_encoders();
1557     if (todo.decoder_algorithms)
1558         list_decoders();
1559     if (todo.keymanager_algorithms)
1560         list_keymanagers();
1561     if (todo.signature_algorithms)
1562         list_signatures();
1563     if (todo.asym_cipher_algorithms)
1564         list_asymciphers();
1565     if (todo.keyexchange_algorithms)
1566         list_keyexchanges();
1567     if (todo.kem_algorithms)
1568         list_kems();
1569     if (todo.pk_algorithms)
1570         list_pkey();
1571     if (todo.pk_method)
1572         list_pkey_meth();
1573     if (todo.provider_info)
1574         list_provider_info();
1575 #ifndef OPENSSL_NO_DEPRECATED_3_0
1576     if (todo.engines)
1577         list_engines();
1578 #endif
1579     if (todo.disabled)
1580         list_disabled();
1581     if (todo.missing_help)
1582         list_missing_help();
1583     if (todo.objects)
1584         list_objects();
1585
1586     if (!done)
1587         goto opthelp;
1588
1589     return 0;
1590 }