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