apps/list.c

   1 /*
   2  * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <string.h>
  11 #include <openssl/evp.h>
  12 #include <openssl/err.h>
  13 #include <openssl/provider.h>
  14 #include <openssl/safestack.h>
  15 #include <openssl/kdf.h>
  16 #include "apps.h"
  17 #include "app_params.h"
  18 #include "progs.h"
  19 #include "opt.h"
  20 #include "names.h"
  21
  22 static int verbose = 0;
  23
  24 static void legacy_cipher_fn(const EVP_CIPHER *c,
  25                              const char *from, const char *to, void *arg)
  26 {
  27     if (c != NULL) {
  28         BIO_printf(arg, "  %s\n", EVP_CIPHER_name(c));
  29     } else {
  30         if (from == NULL)
  31             from = "<undefined>";
  32         if (to == NULL)
  33             to = "<undefined>";
  34         BIO_printf(arg, "  %s => %s\n", from, to);
  35     }
  36 }
  37
  38 DEFINE_STACK_OF(EVP_CIPHER)
  39 static int cipher_cmp(const EVP_CIPHER * const *a,
  40                       const EVP_CIPHER * const *b)
  41 {
  42     int ret = EVP_CIPHER_number(*a) - EVP_CIPHER_number(*b);
  43
  44     if (ret == 0)
  45         ret = strcmp(OSSL_PROVIDER_name(EVP_CIPHER_provider(*a)),
  46                      OSSL_PROVIDER_name(EVP_CIPHER_provider(*b)));
  47
  48     return ret;
  49 }
  50
  51 static void collect_ciphers(EVP_CIPHER *cipher, void *stack)
  52 {
  53     STACK_OF(EVP_CIPHER) *cipher_stack = stack;
  54
  55     if (sk_EVP_CIPHER_push(cipher_stack, cipher) > 0)
  56         EVP_CIPHER_up_ref(cipher);
  57 }
  58
  59 static void list_ciphers(void)
  60 {
  61     STACK_OF(EVP_CIPHER) *ciphers = sk_EVP_CIPHER_new(cipher_cmp);
  62     int i;
  63
  64     BIO_printf(bio_out, "Legacy:\n");
  65     EVP_CIPHER_do_all_sorted(legacy_cipher_fn, bio_out);
  66
  67     BIO_printf(bio_out, "Provided:\n");
  68     EVP_CIPHER_do_all_provided(NULL, collect_ciphers, ciphers);
  69     sk_EVP_CIPHER_sort(ciphers);
  70     for (i = 0; i < sk_EVP_CIPHER_num(ciphers); i++) {
  71         const EVP_CIPHER *c = sk_EVP_CIPHER_value(ciphers, i);
  72         STACK_OF(OPENSSL_CSTRING) *names =
  73             sk_OPENSSL_CSTRING_new(name_cmp);
  74
  75         EVP_CIPHER_names_do_all(c, collect_names, names);
  76
  77         BIO_printf(bio_out, "  ");
  78         print_names(bio_out, names);
  79         BIO_printf(bio_out, " @ %s\n",
  80                    OSSL_PROVIDER_name(EVP_CIPHER_provider(c)));
  81
  82         sk_OPENSSL_CSTRING_free(names);
  83
  84         if (verbose) {
  85             print_param_types("retrievable algorithm parameters",
  86                               EVP_CIPHER_gettable_params(c), 4);
  87             print_param_types("retrievable operation parameters",
  88                               EVP_CIPHER_gettable_ctx_params(c), 4);
  89             print_param_types("settable operation parameters",
  90                               EVP_CIPHER_settable_ctx_params(c), 4);
  91         }
  92     }
  93     sk_EVP_CIPHER_pop_free(ciphers, EVP_CIPHER_free);
  94 }
  95
  96 static void list_md_fn(const EVP_MD *m,
  97                        const char *from, const char *to, void *arg)
  98 {
  99     if (m != NULL) {
 100         BIO_printf(arg, "  %s\n", EVP_MD_name(m));
 101     } else {
 102         if (from == NULL)
 103             from = "<undefined>";
 104         if (to == NULL)
 105             to = "<undefined>";
 106         BIO_printf((BIO *)arg, "  %s => %s\n", from, to);
 107     }
 108 }
 109
 110 DEFINE_STACK_OF(EVP_MD)
 111 static int md_cmp(const EVP_MD * const *a, const EVP_MD * const *b)
 112 {
 113     int ret = EVP_MD_number(*a) - EVP_MD_number(*b);
 114
 115     if (ret == 0)
 116         ret = strcmp(OSSL_PROVIDER_name(EVP_MD_provider(*a)),
 117                      OSSL_PROVIDER_name(EVP_MD_provider(*b)));
 118
 119     return ret;
 120 }
 121
 122 static void collect_digests(EVP_MD *md, void *stack)
 123 {
 124     STACK_OF(EVP_MD) *digest_stack = stack;
 125
 126     if (sk_EVP_MD_push(digest_stack, md) > 0)
 127         EVP_MD_up_ref(md);
 128 }
 129
 130 static void list_digests(void)
 131 {
 132     STACK_OF(EVP_MD) *digests = sk_EVP_MD_new(md_cmp);
 133     int i;
 134
 135     BIO_printf(bio_out, "Legacy:\n");
 136     EVP_MD_do_all_sorted(list_md_fn, bio_out);
 137
 138     BIO_printf(bio_out, "Provided:\n");
 139     EVP_MD_do_all_provided(NULL, collect_digests, digests);
 140     sk_EVP_MD_sort(digests);
 141     for (i = 0; i < sk_EVP_MD_num(digests); i++) {
 142         const EVP_MD *m = sk_EVP_MD_value(digests, i);
 143         STACK_OF(OPENSSL_CSTRING) *names =
 144             sk_OPENSSL_CSTRING_new(name_cmp);
 145
 146         EVP_MD_names_do_all(m, collect_names, names);
 147
 148         BIO_printf(bio_out, "  ");
 149         print_names(bio_out, names);
 150         BIO_printf(bio_out, " @ %s\n",
 151                    OSSL_PROVIDER_name(EVP_MD_provider(m)));
 152
 153         sk_OPENSSL_CSTRING_free(names);
 154
 155         if (verbose) {
 156             print_param_types("retrievable algorithm parameters",
 157                               EVP_MD_gettable_params(m), 4);
 158             print_param_types("retrievable operation parameters",
 159                               EVP_MD_gettable_ctx_params(m), 4);
 160             print_param_types("settable operation parameters",
 161                               EVP_MD_settable_ctx_params(m), 4);
 162         }
 163     }
 164     sk_EVP_MD_pop_free(digests, EVP_MD_free);
 165 }
 166
 167 DEFINE_STACK_OF(EVP_MAC)
 168 static int mac_cmp(const EVP_MAC * const *a, const EVP_MAC * const *b)
 169 {
 170     int ret = EVP_MAC_number(*a) - EVP_MAC_number(*b);
 171
 172     if (ret == 0)
 173         ret = strcmp(OSSL_PROVIDER_name(EVP_MAC_provider(*a)),
 174                      OSSL_PROVIDER_name(EVP_MAC_provider(*b)));
 175
 176     return ret;
 177 }
 178
 179 static void collect_macs(EVP_MAC *mac, void *stack)
 180 {
 181     STACK_OF(EVP_MAC) *mac_stack = stack;
 182
 183     if (sk_EVP_MAC_push(mac_stack, mac) > 0)
 184         EVP_MAC_up_ref(mac);
 185 }
 186
 187 static void list_macs(void)
 188 {
 189     STACK_OF(EVP_MAC) *macs = sk_EVP_MAC_new(mac_cmp);
 190     int i;
 191
 192     BIO_printf(bio_out, "Provided MACs:\n");
 193     EVP_MAC_do_all_provided(NULL, collect_macs, macs);
 194     sk_EVP_MAC_sort(macs);
 195     for (i = 0; i < sk_EVP_MAC_num(macs); i++) {
 196         const EVP_MAC *m = sk_EVP_MAC_value(macs, i);
 197         STACK_OF(OPENSSL_CSTRING) *names =
 198             sk_OPENSSL_CSTRING_new(name_cmp);
 199
 200         EVP_MAC_names_do_all(m, collect_names, names);
 201
 202         BIO_printf(bio_out, "  ");
 203         print_names(bio_out, names);
 204         BIO_printf(bio_out, " @ %s\n",
 205                    OSSL_PROVIDER_name(EVP_MAC_provider(m)));
 206
 207         sk_OPENSSL_CSTRING_free(names);
 208
 209         if (verbose) {
 210             print_param_types("retrievable algorithm parameters",
 211                               EVP_MAC_gettable_params(m), 4);
 212             print_param_types("retrievable operation parameters",
 213                               EVP_MAC_gettable_ctx_params(m), 4);
 214             print_param_types("settable operation parameters",
 215                               EVP_MAC_settable_ctx_params(m), 4);
 216         }
 217     }
 218     sk_EVP_MAC_pop_free(macs, EVP_MAC_free);
 219 }
 220
 221 /*
 222  * KDFs and PRFs
 223  */
 224 DEFINE_STACK_OF(EVP_KDF)
 225 static int kdf_cmp(const EVP_KDF * const *a, const EVP_KDF * const *b)
 226 {
 227     int ret = EVP_KDF_number(*a) - EVP_KDF_number(*b);
 228
 229     if (ret == 0)
 230         ret = strcmp(OSSL_PROVIDER_name(EVP_KDF_provider(*a)),
 231                      OSSL_PROVIDER_name(EVP_KDF_provider(*b)));
 232
 233     return ret;
 234 }
 235
 236 static void collect_kdfs(EVP_KDF *kdf, void *stack)
 237 {
 238     STACK_OF(EVP_KDF) *kdf_stack = stack;
 239
 240     sk_EVP_KDF_push(kdf_stack, kdf);
 241     EVP_KDF_up_ref(kdf);
 242 }
 243
 244 static void list_kdfs(void)
 245 {
 246     STACK_OF(EVP_KDF) *kdfs = sk_EVP_KDF_new(kdf_cmp);
 247     int i;
 248
 249     BIO_printf(bio_out, "Provided KDFs and PDFs:\n");
 250     EVP_KDF_do_all_provided(NULL, collect_kdfs, kdfs);
 251     sk_EVP_KDF_sort(kdfs);
 252     for (i = 0; i < sk_EVP_KDF_num(kdfs); i++) {
 253         const EVP_KDF *k = sk_EVP_KDF_value(kdfs, i);
 254         STACK_OF(OPENSSL_CSTRING) *names =
 255             sk_OPENSSL_CSTRING_new(name_cmp);
 256
 257         EVP_KDF_names_do_all(k, collect_names, names);
 258
 259         BIO_printf(bio_out, "  ");
 260         print_names(bio_out, names);
 261         BIO_printf(bio_out, " @ %s\n",
 262                    OSSL_PROVIDER_name(EVP_KDF_provider(k)));
 263
 264         sk_OPENSSL_CSTRING_free(names);
 265
 266         if (verbose) {
 267             print_param_types("retrievable algorithm parameters",
 268                               EVP_KDF_gettable_params(k), 4);
 269             print_param_types("retrievable operation parameters",
 270                               EVP_KDF_gettable_ctx_params(k), 4);
 271             print_param_types("settable operation parameters",
 272                               EVP_KDF_settable_ctx_params(k), 4);
 273         }
 274     }
 275     sk_EVP_KDF_pop_free(kdfs, EVP_KDF_free);
 276 }
 277
 278 static void list_missing_help(void)
 279 {
 280     const FUNCTION *fp;
 281     const OPTIONS *o;
 282
 283     for (fp = functions; fp->name != NULL; fp++) {
 284         if ((o = fp->help) != NULL) {
 285             /* If there is help, list what flags are not documented. */
 286             for ( ; o->name != NULL; o++) {
 287                 if (o->helpstr == NULL)
 288                     BIO_printf(bio_out, "%s %s\n", fp->name, o->name);
 289             }
 290         } else if (fp->func != dgst_main) {
 291             /* If not aliased to the dgst command, */
 292             BIO_printf(bio_out, "%s *\n", fp->name);
 293         }
 294     }
 295 }
 296
 297 static void list_objects(void)
 298 {
 299     int max_nid = OBJ_new_nid(0);
 300     int i;
 301     char *oid_buf = NULL;
 302     int oid_size = 0;
 303
 304     /* Skip 0, since that's NID_undef */
 305     for (i = 1; i < max_nid; i++) {
 306         const ASN1_OBJECT *obj = OBJ_nid2obj(i);
 307         const char *sn = OBJ_nid2sn(i);
 308         const char *ln = OBJ_nid2ln(i);
 309         int n = 0;
 310
 311         /*
 312          * If one of the retrieved objects somehow generated an error,
 313          * we ignore it.  The check for NID_undef below will detect the
 314          * error and simply skip to the next NID.
 315          */
 316         ERR_clear_error();
 317
 318         if (OBJ_obj2nid(obj) == NID_undef)
 319             continue;
 320
 321         if ((n = OBJ_obj2txt(NULL, 0, obj, 1)) == 0) {
 322             BIO_printf(bio_out, "# None-OID object: %s, %s\n", sn, ln);
 323             continue;
 324         }
 325         if (n < 0)
 326             break;               /* Error */
 327
 328         if (n > oid_size) {
 329             oid_buf = OPENSSL_realloc(oid_buf, n + 1);
 330             if (oid_buf == NULL) {
 331                 BIO_printf(bio_err, "ERROR: Memory allocation\n");
 332                 break;           /* Error */
 333             }
 334             oid_size = n + 1;
 335         }
 336         if (OBJ_obj2txt(oid_buf, oid_size, obj, 1) < 0)
 337             break;               /* Error */
 338         if (ln == NULL || strcmp(sn, ln) == 0)
 339             BIO_printf(bio_out, "%s = %s\n", sn, oid_buf);
 340         else
 341             BIO_printf(bio_out, "%s = %s, %s\n", sn, ln, oid_buf);
 342     }
 343
 344     OPENSSL_free(oid_buf);
 345 }
 346
 347 static void list_options_for_command(const char *command)
 348 {
 349     const FUNCTION *fp;
 350     const OPTIONS *o;
 351
 352     for (fp = functions; fp->name != NULL; fp++)
 353         if (strcmp(fp->name, command) == 0)
 354             break;
 355     if (fp->name == NULL) {
 356         BIO_printf(bio_err, "Invalid command '%s'; type \"help\" for a list.\n",
 357                 command);
 358         return;
 359     }
 360
 361     if ((o = fp->help) == NULL)
 362         return;
 363
 364     for ( ; o->name != NULL; o++) {
 365         char c = o->valtype;
 366
 367         if (o->name == OPT_PARAM_STR)
 368             break;
 369
 370         if (o->name == OPT_HELP_STR
 371                 || o->name == OPT_MORE_STR
 372                 || o->name == OPT_SECTION_STR
 373                 || o->name[0] == '\0')
 374             continue;
 375         BIO_printf(bio_out, "%s %c\n", o->name, c == '\0' ? '-' : c);
 376     }
 377     /* Always output the -- marker since it is sometimes documented. */
 378     BIO_printf(bio_out, "- -\n");
 379 }
 380
 381 static void list_type(FUNC_TYPE ft, int one)
 382 {
 383     FUNCTION *fp;
 384     int i = 0;
 385     DISPLAY_COLUMNS dc;
 386
 387     memset(&dc, 0, sizeof(dc));
 388     if (!one)
 389         calculate_columns(functions, &dc);
 390
 391     for (fp = functions; fp->name != NULL; fp++) {
 392         if (fp->type != ft)
 393             continue;
 394         if (one) {
 395             BIO_printf(bio_out, "%s\n", fp->name);
 396         } else {
 397             if (i % dc.columns == 0 && i > 0)
 398                 BIO_printf(bio_out, "\n");
 399             BIO_printf(bio_out, "%-*s", dc.width, fp->name);
 400             i++;
 401         }
 402     }
 403     if (!one)
 404         BIO_printf(bio_out, "\n\n");
 405 }
 406
 407 static void list_pkey(void)
 408 {
 409     int i;
 410
 411     for (i = 0; i < EVP_PKEY_asn1_get_count(); i++) {
 412         const EVP_PKEY_ASN1_METHOD *ameth;
 413         int pkey_id, pkey_base_id, pkey_flags;
 414         const char *pinfo, *pem_str;
 415         ameth = EVP_PKEY_asn1_get0(i);
 416         EVP_PKEY_asn1_get0_info(&pkey_id, &pkey_base_id, &pkey_flags,
 417                                 &pinfo, &pem_str, ameth);
 418         if (pkey_flags & ASN1_PKEY_ALIAS) {
 419             BIO_printf(bio_out, "Name: %s\n", OBJ_nid2ln(pkey_id));
 420             BIO_printf(bio_out, "\tAlias for: %s\n",
 421                        OBJ_nid2ln(pkey_base_id));
 422         } else {
 423             BIO_printf(bio_out, "Name: %s\n", pinfo);
 424             BIO_printf(bio_out, "\tType: %s Algorithm\n",
 425                        pkey_flags & ASN1_PKEY_DYNAMIC ?
 426                        "External" : "Builtin");
 427             BIO_printf(bio_out, "\tOID: %s\n", OBJ_nid2ln(pkey_id));
 428             if (pem_str == NULL)
 429                 pem_str = "(none)";
 430             BIO_printf(bio_out, "\tPEM string: %s\n", pem_str);
 431         }
 432
 433     }
 434 }
 435
 436 static void list_pkey_meth(void)
 437 {
 438     size_t i;
 439     size_t meth_count = EVP_PKEY_meth_get_count();
 440
 441     for (i = 0; i < meth_count; i++) {
 442         const EVP_PKEY_METHOD *pmeth = EVP_PKEY_meth_get0(i);
 443         int pkey_id, pkey_flags;
 444
 445         EVP_PKEY_meth_get0_info(&pkey_id, &pkey_flags, pmeth);
 446         BIO_printf(bio_out, "%s\n", OBJ_nid2ln(pkey_id));
 447         BIO_printf(bio_out, "\tType: %s Algorithm\n",
 448                    pkey_flags & ASN1_PKEY_DYNAMIC ?  "External" : "Builtin");
 449     }
 450 }
 451
 452 static void list_engines(void)
 453 {
 454 #ifndef OPENSSL_NO_ENGINE
 455     ENGINE *e;
 456
 457     BIO_puts(bio_out, "Engines:\n");
 458     e = ENGINE_get_first();
 459     while (e) {
 460         BIO_printf(bio_out, "%s\n", ENGINE_get_id(e));
 461         e = ENGINE_get_next(e);
 462     }
 463 #else
 464     BIO_puts(bio_out, "Engine support is disabled.\n");
 465 #endif
 466 }
 467
 468 static void list_disabled(void)
 469 {
 470     BIO_puts(bio_out, "Disabled algorithms:\n");
 471 #ifdef OPENSSL_NO_ARIA
 472     BIO_puts(bio_out, "ARIA\n");
 473 #endif
 474 #ifdef OPENSSL_NO_BF
 475     BIO_puts(bio_out, "BF\n");
 476 #endif
 477 #ifdef OPENSSL_NO_BLAKE2
 478     BIO_puts(bio_out, "BLAKE2\n");
 479 #endif
 480 #ifdef OPENSSL_NO_CAMELLIA
 481     BIO_puts(bio_out, "CAMELLIA\n");
 482 #endif
 483 #ifdef OPENSSL_NO_CAST
 484     BIO_puts(bio_out, "CAST\n");
 485 #endif
 486 #ifdef OPENSSL_NO_CMAC
 487     BIO_puts(bio_out, "CMAC\n");
 488 #endif
 489 #ifdef OPENSSL_NO_CMS
 490     BIO_puts(bio_out, "CMS\n");
 491 #endif
 492 #ifdef OPENSSL_NO_COMP
 493     BIO_puts(bio_out, "COMP\n");
 494 #endif
 495 #ifdef OPENSSL_NO_DES
 496     BIO_puts(bio_out, "DES\n");
 497 #endif
 498 #ifdef OPENSSL_NO_DGRAM
 499     BIO_puts(bio_out, "DGRAM\n");
 500 #endif
 501 #ifdef OPENSSL_NO_DH
 502     BIO_puts(bio_out, "DH\n");
 503 #endif
 504 #ifdef OPENSSL_NO_DSA
 505     BIO_puts(bio_out, "DSA\n");
 506 #endif
 507 #if defined(OPENSSL_NO_DTLS)
 508     BIO_puts(bio_out, "DTLS\n");
 509 #endif
 510 #if defined(OPENSSL_NO_DTLS1)
 511     BIO_puts(bio_out, "DTLS1\n");
 512 #endif
 513 #if defined(OPENSSL_NO_DTLS1_2)
 514     BIO_puts(bio_out, "DTLS1_2\n");
 515 #endif
 516 #ifdef OPENSSL_NO_EC
 517     BIO_puts(bio_out, "EC\n");
 518 #endif
 519 #ifdef OPENSSL_NO_EC2M
 520     BIO_puts(bio_out, "EC2M\n");
 521 #endif
 522 #ifdef OPENSSL_NO_ENGINE
 523     BIO_puts(bio_out, "ENGINE\n");
 524 #endif
 525 #ifdef OPENSSL_NO_GOST
 526     BIO_puts(bio_out, "GOST\n");
 527 #endif
 528 #ifdef OPENSSL_NO_IDEA
 529     BIO_puts(bio_out, "IDEA\n");
 530 #endif
 531 #ifdef OPENSSL_NO_MD2
 532     BIO_puts(bio_out, "MD2\n");
 533 #endif
 534 #ifdef OPENSSL_NO_MD4
 535     BIO_puts(bio_out, "MD4\n");
 536 #endif
 537 #ifdef OPENSSL_NO_MD5
 538     BIO_puts(bio_out, "MD5\n");
 539 #endif
 540 #ifdef OPENSSL_NO_MDC2
 541     BIO_puts(bio_out, "MDC2\n");
 542 #endif
 543 #ifdef OPENSSL_NO_OCB
 544     BIO_puts(bio_out, "OCB\n");
 545 #endif
 546 #ifdef OPENSSL_NO_OCSP
 547     BIO_puts(bio_out, "OCSP\n");
 548 #endif
 549 #ifdef OPENSSL_NO_PSK
 550     BIO_puts(bio_out, "PSK\n");
 551 #endif
 552 #ifdef OPENSSL_NO_RC2
 553     BIO_puts(bio_out, "RC2\n");
 554 #endif
 555 #ifdef OPENSSL_NO_RC4
 556     BIO_puts(bio_out, "RC4\n");
 557 #endif
 558 #ifdef OPENSSL_NO_RC5
 559     BIO_puts(bio_out, "RC5\n");
 560 #endif
 561 #ifdef OPENSSL_NO_RMD160
 562     BIO_puts(bio_out, "RMD160\n");
 563 #endif
 564 #ifdef OPENSSL_NO_RSA
 565     BIO_puts(bio_out, "RSA\n");
 566 #endif
 567 #ifdef OPENSSL_NO_SCRYPT
 568     BIO_puts(bio_out, "SCRYPT\n");
 569 #endif
 570 #ifdef OPENSSL_NO_SCTP
 571     BIO_puts(bio_out, "SCTP\n");
 572 #endif
 573 #ifdef OPENSSL_NO_SEED
 574     BIO_puts(bio_out, "SEED\n");
 575 #endif
 576 #ifdef OPENSSL_NO_SM2
 577     BIO_puts(bio_out, "SM2\n");
 578 #endif
 579 #ifdef OPENSSL_NO_SM3
 580     BIO_puts(bio_out, "SM3\n");
 581 #endif
 582 #ifdef OPENSSL_NO_SM4
 583     BIO_puts(bio_out, "SM4\n");
 584 #endif
 585 #ifdef OPENSSL_NO_SOCK
 586     BIO_puts(bio_out, "SOCK\n");
 587 #endif
 588 #ifdef OPENSSL_NO_SRP
 589     BIO_puts(bio_out, "SRP\n");
 590 #endif
 591 #ifdef OPENSSL_NO_SRTP
 592     BIO_puts(bio_out, "SRTP\n");
 593 #endif
 594 #ifdef OPENSSL_NO_SSL3
 595     BIO_puts(bio_out, "SSL3\n");
 596 #endif
 597 #ifdef OPENSSL_NO_TLS1
 598     BIO_puts(bio_out, "TLS1\n");
 599 #endif
 600 #ifdef OPENSSL_NO_TLS1_1
 601     BIO_puts(bio_out, "TLS1_1\n");
 602 #endif
 603 #ifdef OPENSSL_NO_TLS1_2
 604     BIO_puts(bio_out, "TLS1_2\n");
 605 #endif
 606 #ifdef OPENSSL_NO_WHIRLPOOL
 607     BIO_puts(bio_out, "WHIRLPOOL\n");
 608 #endif
 609 #ifndef ZLIB
 610     BIO_puts(bio_out, "ZLIB\n");
 611 #endif
 612 }
 613
 614 /* Unified enum for help and list commands. */
 615 typedef enum HELPLIST_CHOICE {
 616     OPT_ERR = -1, OPT_EOF = 0, OPT_HELP, OPT_ONE, OPT_VERBOSE,
 617     OPT_COMMANDS, OPT_DIGEST_COMMANDS, OPT_MAC_ALGORITHMS, OPT_OPTIONS,
 618     OPT_DIGEST_ALGORITHMS, OPT_CIPHER_COMMANDS, OPT_CIPHER_ALGORITHMS,
 619     OPT_PK_ALGORITHMS, OPT_PK_METHOD, OPT_ENGINES, OPT_DISABLED,
 620     OPT_KDF_ALGORITHMS, OPT_MISSING_HELP, OPT_OBJECTS,
 621     OPT_PROV_ENUM
 622 } HELPLIST_CHOICE;
 623
 624 const OPTIONS list_options[] = {
 625
 626     OPT_SECTION("General"),
 627     {"help", OPT_HELP, '-', "Display this summary"},
 628
 629     OPT_SECTION("Output"),
 630     {"1", OPT_ONE, '-', "List in one column"},
 631     {"verbose", OPT_VERBOSE, '-', "Verbose listing"},
 632     {"commands", OPT_COMMANDS, '-', "List of standard commands"},
 633     {"standard-commands", OPT_COMMANDS, '-', "List of standard commands"},
 634     {"digest-commands", OPT_DIGEST_COMMANDS, '-',
 635      "List of message digest commands"},
 636     {"digest-algorithms", OPT_DIGEST_ALGORITHMS, '-',
 637      "List of message digest algorithms"},
 638     {"kdf-algorithms", OPT_KDF_ALGORITHMS, '-',
 639      "List of key derivation and pseudo random function algorithms"},
 640     {"mac-algorithms", OPT_MAC_ALGORITHMS, '-',
 641      "List of message authentication code algorithms"},
 642     {"cipher-commands", OPT_CIPHER_COMMANDS, '-', "List of cipher commands"},
 643     {"cipher-algorithms", OPT_CIPHER_ALGORITHMS, '-',
 644      "List of cipher algorithms"},
 645     {"public-key-algorithms", OPT_PK_ALGORITHMS, '-',
 646      "List of public key algorithms"},
 647     {"public-key-methods", OPT_PK_METHOD, '-',
 648      "List of public key methods"},
 649     {"engines", OPT_ENGINES, '-',
 650      "List of loaded engines"},
 651     {"disabled", OPT_DISABLED, '-',
 652      "List of disabled features"},
 653     {"missing-help", OPT_MISSING_HELP, '-',
 654      "List missing detailed help strings"},
 655     {"options", OPT_OPTIONS, 's',
 656      "List options for specified command"},
 657     {"objects", OPT_OBJECTS, '-',
 658      "List built in objects (OID<->name mappings)"},
 659
 660     OPT_PROV_OPTIONS,
 661     {NULL}
 662 };
 663
 664 int list_main(int argc, char **argv)
 665 {
 666     char *prog;
 667     HELPLIST_CHOICE o;
 668     int one = 0, done = 0;
 669     struct {
 670         unsigned int commands:1;
 671         unsigned int digest_commands:1;
 672         unsigned int digest_algorithms:1;
 673         unsigned int kdf_algorithms:1;
 674         unsigned int mac_algorithms:1;
 675         unsigned int cipher_commands:1;
 676         unsigned int cipher_algorithms:1;
 677         unsigned int pk_algorithms:1;
 678         unsigned int pk_method:1;
 679         unsigned int engines:1;
 680         unsigned int disabled:1;
 681         unsigned int missing_help:1;
 682         unsigned int objects:1;
 683         unsigned int options:1;
 684     } todo = { 0, };
 685
 686     verbose = 0;                 /* Clear a possible previous call */
 687
 688     prog = opt_init(argc, argv, list_options);
 689     while ((o = opt_next()) != OPT_EOF) {
 690         switch (o) {
 691         case OPT_EOF:  /* Never hit, but suppresses warning */
 692         case OPT_ERR:
 693 opthelp:
 694             BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
 695             return 1;
 696         case OPT_HELP:
 697             opt_help(list_options);
 698             break;
 699         case OPT_ONE:
 700             one = 1;
 701             break;
 702         case OPT_COMMANDS:
 703             todo.commands = 1;
 704             break;
 705         case OPT_DIGEST_COMMANDS:
 706             todo.digest_commands = 1;
 707             break;
 708         case OPT_DIGEST_ALGORITHMS:
 709             todo.digest_algorithms = 1;
 710             break;
 711         case OPT_KDF_ALGORITHMS:
 712             todo.kdf_algorithms = 1;
 713             break;
 714         case OPT_MAC_ALGORITHMS:
 715             todo.mac_algorithms = 1;
 716             break;
 717         case OPT_CIPHER_COMMANDS:
 718             todo.cipher_commands = 1;
 719             break;
 720         case OPT_CIPHER_ALGORITHMS:
 721             todo.cipher_algorithms = 1;
 722             break;
 723         case OPT_PK_ALGORITHMS:
 724             todo.pk_algorithms = 1;
 725             break;
 726         case OPT_PK_METHOD:
 727             todo.pk_method = 1;
 728             break;
 729         case OPT_ENGINES:
 730             todo.engines = 1;
 731             break;
 732         case OPT_DISABLED:
 733             todo.disabled = 1;
 734             break;
 735         case OPT_MISSING_HELP:
 736             todo.missing_help = 1;
 737             break;
 738         case OPT_OBJECTS:
 739             todo.objects = 1;
 740             break;
 741         case OPT_OPTIONS:
 742             list_options_for_command(opt_arg());
 743             break;
 744         case OPT_VERBOSE:
 745             verbose = 1;
 746             break;
 747         case OPT_PROV_CASES:
 748             if (!opt_provider(o))
 749                 return 1;
 750             break;
 751         }
 752         done = 1;
 753     }
 754     if (opt_num_rest() != 0) {
 755         BIO_printf(bio_err, "Extra arguments given.\n");
 756         goto opthelp;
 757     }
 758
 759     if (todo.commands)
 760         list_type(FT_general, one);
 761     if (todo.digest_commands)
 762         list_type(FT_md, one);
 763     if (todo.digest_algorithms)
 764         list_digests();
 765     if (todo.kdf_algorithms)
 766         list_kdfs();
 767     if (todo.mac_algorithms)
 768         list_macs();
 769     if (todo.cipher_commands)
 770         list_type(FT_cipher, one);
 771     if (todo.cipher_algorithms)
 772         list_ciphers();
 773     if (todo.pk_algorithms)
 774         list_pkey();
 775     if (todo.pk_method)
 776         list_pkey_meth();
 777     if (todo.engines)
 778         list_engines();
 779     if (todo.disabled)
 780         list_disabled();
 781     if (todo.missing_help)
 782         list_missing_help();
 783     if (todo.objects)
 784         list_objects();
 785
 786     if (!done)
 787         goto opthelp;
 788
 789     return 0;
 790 }