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_HELP_STR
 368                 || o->name == OPT_MORE_STR
 369                 || o->name == OPT_SECTION_STR
 370                 || o->name[0] == '\0')
 371             continue;
 372         BIO_printf(bio_out, "%s %c\n", o->name, c == '\0' ? '-' : c);
 373     }
 374     /* Always output the -- marker since it is sometimes documented. */
 375     BIO_printf(bio_out, "- -\n");
 376 }
 377
 378 static void list_type(FUNC_TYPE ft, int one)
 379 {
 380     FUNCTION *fp;
 381     int i = 0;
 382     DISPLAY_COLUMNS dc;
 383
 384     memset(&dc, 0, sizeof(dc));
 385     if (!one)
 386         calculate_columns(functions, &dc);
 387
 388     for (fp = functions; fp->name != NULL; fp++) {
 389         if (fp->type != ft)
 390             continue;
 391         if (one) {
 392             BIO_printf(bio_out, "%s\n", fp->name);
 393         } else {
 394             if (i % dc.columns == 0 && i > 0)
 395                 BIO_printf(bio_out, "\n");
 396             BIO_printf(bio_out, "%-*s", dc.width, fp->name);
 397             i++;
 398         }
 399     }
 400     if (!one)
 401         BIO_printf(bio_out, "\n\n");
 402 }
 403
 404 static void list_pkey(void)
 405 {
 406     int i;
 407
 408     for (i = 0; i < EVP_PKEY_asn1_get_count(); i++) {
 409         const EVP_PKEY_ASN1_METHOD *ameth;
 410         int pkey_id, pkey_base_id, pkey_flags;
 411         const char *pinfo, *pem_str;
 412         ameth = EVP_PKEY_asn1_get0(i);
 413         EVP_PKEY_asn1_get0_info(&pkey_id, &pkey_base_id, &pkey_flags,
 414                                 &pinfo, &pem_str, ameth);
 415         if (pkey_flags & ASN1_PKEY_ALIAS) {
 416             BIO_printf(bio_out, "Name: %s\n", OBJ_nid2ln(pkey_id));
 417             BIO_printf(bio_out, "\tAlias for: %s\n",
 418                        OBJ_nid2ln(pkey_base_id));
 419         } else {
 420             BIO_printf(bio_out, "Name: %s\n", pinfo);
 421             BIO_printf(bio_out, "\tType: %s Algorithm\n",
 422                        pkey_flags & ASN1_PKEY_DYNAMIC ?
 423                        "External" : "Builtin");
 424             BIO_printf(bio_out, "\tOID: %s\n", OBJ_nid2ln(pkey_id));
 425             if (pem_str == NULL)
 426                 pem_str = "(none)";
 427             BIO_printf(bio_out, "\tPEM string: %s\n", pem_str);
 428         }
 429
 430     }
 431 }
 432
 433 static void list_pkey_meth(void)
 434 {
 435     size_t i;
 436     size_t meth_count = EVP_PKEY_meth_get_count();
 437
 438     for (i = 0; i < meth_count; i++) {
 439         const EVP_PKEY_METHOD *pmeth = EVP_PKEY_meth_get0(i);
 440         int pkey_id, pkey_flags;
 441
 442         EVP_PKEY_meth_get0_info(&pkey_id, &pkey_flags, pmeth);
 443         BIO_printf(bio_out, "%s\n", OBJ_nid2ln(pkey_id));
 444         BIO_printf(bio_out, "\tType: %s Algorithm\n",
 445                    pkey_flags & ASN1_PKEY_DYNAMIC ?  "External" : "Builtin");
 446     }
 447 }
 448
 449 static void list_engines(void)
 450 {
 451 #ifndef OPENSSL_NO_ENGINE
 452     ENGINE *e;
 453
 454     BIO_puts(bio_out, "Engines:\n");
 455     e = ENGINE_get_first();
 456     while (e) {
 457         BIO_printf(bio_out, "%s\n", ENGINE_get_id(e));
 458         e = ENGINE_get_next(e);
 459     }
 460 #else
 461     BIO_puts(bio_out, "Engine support is disabled.\n");
 462 #endif
 463 }
 464
 465 static void list_disabled(void)
 466 {
 467     BIO_puts(bio_out, "Disabled algorithms:\n");
 468 #ifdef OPENSSL_NO_ARIA
 469     BIO_puts(bio_out, "ARIA\n");
 470 #endif
 471 #ifdef OPENSSL_NO_BF
 472     BIO_puts(bio_out, "BF\n");
 473 #endif
 474 #ifdef OPENSSL_NO_BLAKE2
 475     BIO_puts(bio_out, "BLAKE2\n");
 476 #endif
 477 #ifdef OPENSSL_NO_CAMELLIA
 478     BIO_puts(bio_out, "CAMELLIA\n");
 479 #endif
 480 #ifdef OPENSSL_NO_CAST
 481     BIO_puts(bio_out, "CAST\n");
 482 #endif
 483 #ifdef OPENSSL_NO_CMAC
 484     BIO_puts(bio_out, "CMAC\n");
 485 #endif
 486 #ifdef OPENSSL_NO_CMS
 487     BIO_puts(bio_out, "CMS\n");
 488 #endif
 489 #ifdef OPENSSL_NO_COMP
 490     BIO_puts(bio_out, "COMP\n");
 491 #endif
 492 #ifdef OPENSSL_NO_DES
 493     BIO_puts(bio_out, "DES\n");
 494 #endif
 495 #ifdef OPENSSL_NO_DGRAM
 496     BIO_puts(bio_out, "DGRAM\n");
 497 #endif
 498 #ifdef OPENSSL_NO_DH
 499     BIO_puts(bio_out, "DH\n");
 500 #endif
 501 #ifdef OPENSSL_NO_DSA
 502     BIO_puts(bio_out, "DSA\n");
 503 #endif
 504 #if defined(OPENSSL_NO_DTLS)
 505     BIO_puts(bio_out, "DTLS\n");
 506 #endif
 507 #if defined(OPENSSL_NO_DTLS1)
 508     BIO_puts(bio_out, "DTLS1\n");
 509 #endif
 510 #if defined(OPENSSL_NO_DTLS1_2)
 511     BIO_puts(bio_out, "DTLS1_2\n");
 512 #endif
 513 #ifdef OPENSSL_NO_EC
 514     BIO_puts(bio_out, "EC\n");
 515 #endif
 516 #ifdef OPENSSL_NO_EC2M
 517     BIO_puts(bio_out, "EC2M\n");
 518 #endif
 519 #ifdef OPENSSL_NO_ENGINE
 520     BIO_puts(bio_out, "ENGINE\n");
 521 #endif
 522 #ifdef OPENSSL_NO_GOST
 523     BIO_puts(bio_out, "GOST\n");
 524 #endif
 525 #ifdef OPENSSL_NO_IDEA
 526     BIO_puts(bio_out, "IDEA\n");
 527 #endif
 528 #ifdef OPENSSL_NO_MD2
 529     BIO_puts(bio_out, "MD2\n");
 530 #endif
 531 #ifdef OPENSSL_NO_MD4
 532     BIO_puts(bio_out, "MD4\n");
 533 #endif
 534 #ifdef OPENSSL_NO_MD5
 535     BIO_puts(bio_out, "MD5\n");
 536 #endif
 537 #ifdef OPENSSL_NO_MDC2
 538     BIO_puts(bio_out, "MDC2\n");
 539 #endif
 540 #ifdef OPENSSL_NO_OCB
 541     BIO_puts(bio_out, "OCB\n");
 542 #endif
 543 #ifdef OPENSSL_NO_OCSP
 544     BIO_puts(bio_out, "OCSP\n");
 545 #endif
 546 #ifdef OPENSSL_NO_PSK
 547     BIO_puts(bio_out, "PSK\n");
 548 #endif
 549 #ifdef OPENSSL_NO_RC2
 550     BIO_puts(bio_out, "RC2\n");
 551 #endif
 552 #ifdef OPENSSL_NO_RC4
 553     BIO_puts(bio_out, "RC4\n");
 554 #endif
 555 #ifdef OPENSSL_NO_RC5
 556     BIO_puts(bio_out, "RC5\n");
 557 #endif
 558 #ifdef OPENSSL_NO_RMD160
 559     BIO_puts(bio_out, "RMD160\n");
 560 #endif
 561 #ifdef OPENSSL_NO_RSA
 562     BIO_puts(bio_out, "RSA\n");
 563 #endif
 564 #ifdef OPENSSL_NO_SCRYPT
 565     BIO_puts(bio_out, "SCRYPT\n");
 566 #endif
 567 #ifdef OPENSSL_NO_SCTP
 568     BIO_puts(bio_out, "SCTP\n");
 569 #endif
 570 #ifdef OPENSSL_NO_SEED
 571     BIO_puts(bio_out, "SEED\n");
 572 #endif
 573 #ifdef OPENSSL_NO_SM2
 574     BIO_puts(bio_out, "SM2\n");
 575 #endif
 576 #ifdef OPENSSL_NO_SM3
 577     BIO_puts(bio_out, "SM3\n");
 578 #endif
 579 #ifdef OPENSSL_NO_SM4
 580     BIO_puts(bio_out, "SM4\n");
 581 #endif
 582 #ifdef OPENSSL_NO_SOCK
 583     BIO_puts(bio_out, "SOCK\n");
 584 #endif
 585 #ifdef OPENSSL_NO_SRP
 586     BIO_puts(bio_out, "SRP\n");
 587 #endif
 588 #ifdef OPENSSL_NO_SRTP
 589     BIO_puts(bio_out, "SRTP\n");
 590 #endif
 591 #ifdef OPENSSL_NO_SSL3
 592     BIO_puts(bio_out, "SSL3\n");
 593 #endif
 594 #ifdef OPENSSL_NO_TLS1
 595     BIO_puts(bio_out, "TLS1\n");
 596 #endif
 597 #ifdef OPENSSL_NO_TLS1_1
 598     BIO_puts(bio_out, "TLS1_1\n");
 599 #endif
 600 #ifdef OPENSSL_NO_TLS1_2
 601     BIO_puts(bio_out, "TLS1_2\n");
 602 #endif
 603 #ifdef OPENSSL_NO_WHIRLPOOL
 604     BIO_puts(bio_out, "WHIRLPOOL\n");
 605 #endif
 606 #ifndef ZLIB
 607     BIO_puts(bio_out, "ZLIB\n");
 608 #endif
 609 }
 610
 611 /* Unified enum for help and list commands. */
 612 typedef enum HELPLIST_CHOICE {
 613     OPT_ERR = -1, OPT_EOF = 0, OPT_HELP, OPT_ONE, OPT_VERBOSE,
 614     OPT_COMMANDS, OPT_DIGEST_COMMANDS, OPT_MAC_ALGORITHMS, OPT_OPTIONS,
 615     OPT_DIGEST_ALGORITHMS, OPT_CIPHER_COMMANDS, OPT_CIPHER_ALGORITHMS,
 616     OPT_PK_ALGORITHMS, OPT_PK_METHOD, OPT_ENGINES, OPT_DISABLED,
 617     OPT_KDF_ALGORITHMS, OPT_MISSING_HELP, OPT_OBJECTS
 618 } HELPLIST_CHOICE;
 619
 620 const OPTIONS list_options[] = {
 621
 622     OPT_SECTION("General"),
 623     {"help", OPT_HELP, '-', "Display this summary"},
 624
 625     OPT_SECTION("Output"),
 626     {"1", OPT_ONE, '-', "List in one column"},
 627     {"verbose", OPT_VERBOSE, '-', "Verbose listing"},
 628     {"commands", OPT_COMMANDS, '-', "List of standard commands"},
 629     {"digest-commands", OPT_DIGEST_COMMANDS, '-',
 630      "List of message digest commands"},
 631     {"digest-algorithms", OPT_DIGEST_ALGORITHMS, '-',
 632      "List of message digest algorithms"},
 633     {"kdf-algorithms", OPT_KDF_ALGORITHMS, '-',
 634      "List of key derivation and pseudo random function algorithms"},
 635     {"mac-algorithms", OPT_MAC_ALGORITHMS, '-',
 636      "List of message authentication code algorithms"},
 637     {"cipher-commands", OPT_CIPHER_COMMANDS, '-', "List of cipher commands"},
 638     {"cipher-algorithms", OPT_CIPHER_ALGORITHMS, '-',
 639      "List of cipher algorithms"},
 640     {"public-key-algorithms", OPT_PK_ALGORITHMS, '-',
 641      "List of public key algorithms"},
 642     {"public-key-methods", OPT_PK_METHOD, '-',
 643      "List of public key methods"},
 644     {"engines", OPT_ENGINES, '-',
 645      "List of loaded engines"},
 646     {"disabled", OPT_DISABLED, '-',
 647      "List of disabled features"},
 648     {"missing-help", OPT_MISSING_HELP, '-',
 649      "List missing detailed help strings"},
 650     {"options", OPT_OPTIONS, 's',
 651      "List options for specified command"},
 652     {"objects", OPT_OBJECTS, '-',
 653      "List built in objects (OID<->name mappings)"},
 654     {NULL}
 655 };
 656
 657 int list_main(int argc, char **argv)
 658 {
 659     char *prog;
 660     HELPLIST_CHOICE o;
 661     int one = 0, done = 0;
 662     struct {
 663         unsigned int commands:1;
 664         unsigned int digest_commands:1;
 665         unsigned int digest_algorithms:1;
 666         unsigned int kdf_algorithms:1;
 667         unsigned int mac_algorithms:1;
 668         unsigned int cipher_commands:1;
 669         unsigned int cipher_algorithms:1;
 670         unsigned int pk_algorithms:1;
 671         unsigned int pk_method:1;
 672         unsigned int engines:1;
 673         unsigned int disabled:1;
 674         unsigned int missing_help:1;
 675         unsigned int objects:1;
 676         unsigned int options:1;
 677     } todo = { 0, };
 678
 679     verbose = 0;                 /* Clear a possible previous call */
 680
 681     prog = opt_init(argc, argv, list_options);
 682     while ((o = opt_next()) != OPT_EOF) {
 683         switch (o) {
 684         case OPT_EOF:  /* Never hit, but suppresses warning */
 685         case OPT_ERR:
 686 opthelp:
 687             BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
 688             return 1;
 689         case OPT_HELP:
 690             opt_help(list_options);
 691             break;
 692         case OPT_ONE:
 693             one = 1;
 694             break;
 695         case OPT_COMMANDS:
 696             todo.commands = 1;
 697             break;
 698         case OPT_DIGEST_COMMANDS:
 699             todo.digest_commands = 1;
 700             break;
 701         case OPT_DIGEST_ALGORITHMS:
 702             todo.digest_algorithms = 1;
 703             break;
 704         case OPT_KDF_ALGORITHMS:
 705             todo.kdf_algorithms = 1;
 706             break;
 707         case OPT_MAC_ALGORITHMS:
 708             todo.mac_algorithms = 1;
 709             break;
 710         case OPT_CIPHER_COMMANDS:
 711             todo.cipher_commands = 1;
 712             break;
 713         case OPT_CIPHER_ALGORITHMS:
 714             todo.cipher_algorithms = 1;
 715             break;
 716         case OPT_PK_ALGORITHMS:
 717             todo.pk_algorithms = 1;
 718             break;
 719         case OPT_PK_METHOD:
 720             todo.pk_method = 1;
 721             break;
 722         case OPT_ENGINES:
 723             todo.engines = 1;
 724             break;
 725         case OPT_DISABLED:
 726             todo.disabled = 1;
 727             break;
 728         case OPT_MISSING_HELP:
 729             todo.missing_help = 1;
 730             break;
 731         case OPT_OBJECTS:
 732             todo.objects = 1;
 733             break;
 734         case OPT_OPTIONS:
 735             list_options_for_command(opt_arg());
 736             break;
 737         case OPT_VERBOSE:
 738             verbose = 1;
 739             break;
 740         }
 741         done = 1;
 742     }
 743     if (opt_num_rest() != 0) {
 744         BIO_printf(bio_err, "Extra arguments given.\n");
 745         goto opthelp;
 746     }
 747
 748     if (todo.commands)
 749         list_type(FT_general, one);
 750     if (todo.digest_commands)
 751         list_type(FT_md, one);
 752     if (todo.digest_algorithms)
 753         list_digests();
 754     if (todo.kdf_algorithms)
 755         list_kdfs();
 756     if (todo.mac_algorithms)
 757         list_macs();
 758     if (todo.cipher_commands)
 759         list_type(FT_cipher, one);
 760     if (todo.cipher_algorithms)
 761         list_ciphers();
 762     if (todo.pk_algorithms)
 763         list_pkey();
 764     if (todo.pk_method)
 765         list_pkey_meth();
 766     if (todo.engines)
 767         list_engines();
 768     if (todo.disabled)
 769         list_disabled();
 770     if (todo.missing_help)
 771         list_missing_help();
 772     if (todo.objects)
 773         list_objects();
 774
 775     if (!done)
 776         goto opthelp;
 777
 778     return 0;
 779 }