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