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