apps/list.c

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