]> 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
providers: add Argon2 KDF
[thirdparty/openssl.git] / apps / list.c
CommitLineData
753149d9 1/*
fecb3aae 2 * Copyright 1995-2022 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;
1212
1213 sk_OSSL_PROVIDER_push(provider_stack, provider);
1214 return 1;
1215}
1216
1217static void list_provider_info(void)
1218{
1219 STACK_OF(OSSL_PROVIDER) *providers = sk_OSSL_PROVIDER_new(provider_cmp);
1220 OSSL_PARAM params[5];
1221 char *name, *version, *buildinfo;
1222 int status;
1223 int i;
1224
1225 if (providers == NULL) {
1226 BIO_printf(bio_err, "ERROR: Memory allocation\n");
1227 return;
1228 }
1229 BIO_printf(bio_out, "Providers:\n");
1230 OSSL_PROVIDER_do_all(NULL, &collect_providers, providers);
1231 sk_OSSL_PROVIDER_sort(providers);
1232 for (i = 0; i < sk_OSSL_PROVIDER_num(providers); i++) {
1233 const OSSL_PROVIDER *prov = sk_OSSL_PROVIDER_value(providers, i);
1234
1235 /* Query the "known" information parameters, the order matches below */
1236 params[0] = OSSL_PARAM_construct_utf8_ptr(OSSL_PROV_PARAM_NAME,
1237 &name, 0);
1238 params[1] = OSSL_PARAM_construct_utf8_ptr(OSSL_PROV_PARAM_VERSION,
1239 &version, 0);
1240 params[2] = OSSL_PARAM_construct_int(OSSL_PROV_PARAM_STATUS, &status);
1241 params[3] = OSSL_PARAM_construct_utf8_ptr(OSSL_PROV_PARAM_BUILDINFO,
1242 &buildinfo, 0);
1243 params[4] = OSSL_PARAM_construct_end();
1244 OSSL_PARAM_set_all_unmodified(params);
1245 if (!OSSL_PROVIDER_get_params(prov, params)) {
1246 BIO_printf(bio_err, "ERROR: Unable to query provider parameters\n");
1247 return;
1248 }
1249
1250 /* Print out the provider information, the params order matches above */
c4e91674 1251 BIO_printf(bio_out, " %s\n", OSSL_PROVIDER_get0_name(prov));
f4bd5105
P		 1252 if (OSSL_PARAM_modified(params))
1253 BIO_printf(bio_out, " name: %s\n", name);
1254 if (OSSL_PARAM_modified(params + 1))
1255 BIO_printf(bio_out, " version: %s\n", version);
1256 if (OSSL_PARAM_modified(params + 2))
1257 BIO_printf(bio_out, " status: %sactive\n", status ? "" : "in");
1258 if (verbose) {
1259 if (OSSL_PARAM_modified(params + 3))
1260 BIO_printf(bio_out, " build info: %s\n", buildinfo);
1261 print_param_types("gettable provider parameters",
1262 OSSL_PROVIDER_gettable_params(prov), 4);
1263 }
1264 }
1265 sk_OSSL_PROVIDER_free(providers);
1266}
1267
0a684b09 1268#ifndef OPENSSL_NO_DEPRECATED_3_0
753149d9
RL		 1269static void list_engines(void)
1270{
0a684b09 1271# ifndef OPENSSL_NO_ENGINE
753149d9
RL		 1272 ENGINE *e;
1273
1274 BIO_puts(bio_out, "Engines:\n");
1275 e = ENGINE_get_first();
1276 while (e) {
1277 BIO_printf(bio_out, "%s\n", ENGINE_get_id(e));
1278 e = ENGINE_get_next(e);
1279 }
0a684b09 1280# else
753149d9 1281 BIO_puts(bio_out, "Engine support is disabled.\n");
0a684b09 1282# endif
753149d9 1283}
0a684b09 1284#endif
753149d9
RL		 1285
1286static void list_disabled(void)
1287{
1288 BIO_puts(bio_out, "Disabled algorithms:\n");
6dfa998f
ÄŒK		 1289#ifdef OPENSSL_NO_ARGON2
1290 BIO_puts(bio_out, "ARGON2\n");
1291#endif
753149d9
RL		 1292#ifdef OPENSSL_NO_ARIA
1293 BIO_puts(bio_out, "ARIA\n");
1294#endif
1295#ifdef OPENSSL_NO_BF
1296 BIO_puts(bio_out, "BF\n");
1297#endif
1298#ifdef OPENSSL_NO_BLAKE2
1299 BIO_puts(bio_out, "BLAKE2\n");
1300#endif
1301#ifdef OPENSSL_NO_CAMELLIA
1302 BIO_puts(bio_out, "CAMELLIA\n");
1303#endif
1304#ifdef OPENSSL_NO_CAST
1305 BIO_puts(bio_out, "CAST\n");
1306#endif
1307#ifdef OPENSSL_NO_CMAC
1308 BIO_puts(bio_out, "CMAC\n");
1309#endif
1310#ifdef OPENSSL_NO_CMS
1311 BIO_puts(bio_out, "CMS\n");
1312#endif
1313#ifdef OPENSSL_NO_COMP
1314 BIO_puts(bio_out, "COMP\n");
1315#endif
1316#ifdef OPENSSL_NO_DES
1317 BIO_puts(bio_out, "DES\n");
1318#endif
1319#ifdef OPENSSL_NO_DGRAM
1320 BIO_puts(bio_out, "DGRAM\n");
1321#endif
1322#ifdef OPENSSL_NO_DH
1323 BIO_puts(bio_out, "DH\n");
1324#endif
1325#ifdef OPENSSL_NO_DSA
1326 BIO_puts(bio_out, "DSA\n");
1327#endif
1328#if defined(OPENSSL_NO_DTLS)
1329 BIO_puts(bio_out, "DTLS\n");
1330#endif
1331#if defined(OPENSSL_NO_DTLS1)
1332 BIO_puts(bio_out, "DTLS1\n");
1333#endif
1334#if defined(OPENSSL_NO_DTLS1_2)
1335 BIO_puts(bio_out, "DTLS1_2\n");
1336#endif
1337#ifdef OPENSSL_NO_EC
1338 BIO_puts(bio_out, "EC\n");
1339#endif
1340#ifdef OPENSSL_NO_EC2M
1341 BIO_puts(bio_out, "EC2M\n");
1342#endif
0a684b09 1343#if defined(OPENSSL_NO_ENGINE) && !defined(OPENSSL_NO_DEPRECATED_3_0)
753149d9
RL		 1344 BIO_puts(bio_out, "ENGINE\n");
1345#endif
1346#ifdef OPENSSL_NO_GOST
1347 BIO_puts(bio_out, "GOST\n");
1348#endif
1349#ifdef OPENSSL_NO_IDEA
1350 BIO_puts(bio_out, "IDEA\n");
1351#endif
1352#ifdef OPENSSL_NO_MD2
1353 BIO_puts(bio_out, "MD2\n");
1354#endif
1355#ifdef OPENSSL_NO_MD4
1356 BIO_puts(bio_out, "MD4\n");
1357#endif
1358#ifdef OPENSSL_NO_MD5
1359 BIO_puts(bio_out, "MD5\n");
1360#endif
1361#ifdef OPENSSL_NO_MDC2
1362 BIO_puts(bio_out, "MDC2\n");
1363#endif
1364#ifdef OPENSSL_NO_OCB
1365 BIO_puts(bio_out, "OCB\n");
1366#endif
1367#ifdef OPENSSL_NO_OCSP
1368 BIO_puts(bio_out, "OCSP\n");
1369#endif
1370#ifdef OPENSSL_NO_PSK
1371 BIO_puts(bio_out, "PSK\n");
1372#endif
1373#ifdef OPENSSL_NO_RC2
1374 BIO_puts(bio_out, "RC2\n");
1375#endif
1376#ifdef OPENSSL_NO_RC4
1377 BIO_puts(bio_out, "RC4\n");
1378#endif
1379#ifdef OPENSSL_NO_RC5
1380 BIO_puts(bio_out, "RC5\n");
1381#endif
1382#ifdef OPENSSL_NO_RMD160
1383 BIO_puts(bio_out, "RMD160\n");
1384#endif
753149d9
RL		 1385#ifdef OPENSSL_NO_SCRYPT
1386 BIO_puts(bio_out, "SCRYPT\n");
1387#endif
1388#ifdef OPENSSL_NO_SCTP
1389 BIO_puts(bio_out, "SCTP\n");
1390#endif
1391#ifdef OPENSSL_NO_SEED
1392 BIO_puts(bio_out, "SEED\n");
1393#endif
1394#ifdef OPENSSL_NO_SM2
1395 BIO_puts(bio_out, "SM2\n");
1396#endif
1397#ifdef OPENSSL_NO_SM3
1398 BIO_puts(bio_out, "SM3\n");
1399#endif
1400#ifdef OPENSSL_NO_SM4
1401 BIO_puts(bio_out, "SM4\n");
1402#endif
1403#ifdef OPENSSL_NO_SOCK
1404 BIO_puts(bio_out, "SOCK\n");
1405#endif
1406#ifdef OPENSSL_NO_SRP
1407 BIO_puts(bio_out, "SRP\n");
1408#endif
1409#ifdef OPENSSL_NO_SRTP
1410 BIO_puts(bio_out, "SRTP\n");
1411#endif
1412#ifdef OPENSSL_NO_SSL3
1413 BIO_puts(bio_out, "SSL3\n");
1414#endif
1415#ifdef OPENSSL_NO_TLS1
1416 BIO_puts(bio_out, "TLS1\n");
1417#endif
1418#ifdef OPENSSL_NO_TLS1_1
1419 BIO_puts(bio_out, "TLS1_1\n");
1420#endif
1421#ifdef OPENSSL_NO_TLS1_2
1422 BIO_puts(bio_out, "TLS1_2\n");
1423#endif
1424#ifdef OPENSSL_NO_WHIRLPOOL
1425 BIO_puts(bio_out, "WHIRLPOOL\n");
1426#endif
59d21298 1427#ifdef OPENSSL_NO_ZLIB
753149d9
RL		 1428 BIO_puts(bio_out, "ZLIB\n");
1429#endif
12e96a23
TS		 1430#ifdef OPENSSL_NO_BROTLI
1431 BIO_puts(bio_out, "BROTLI\n");
1432#endif
caf9317d
TS		 1433#ifdef OPENSSL_NO_ZSTD
1434 BIO_puts(bio_out, "ZSTD\n");
1435#endif
753149d9
RL		 1436}
1437
1438/* Unified enum for help and list commands. */
1439typedef enum HELPLIST_CHOICE {
b0f96018
DDO		 1440 OPT_COMMON,
1441 OPT_ONE, OPT_VERBOSE,
35b67070 1442 OPT_ALL_ARGORITHMS,
753149d9
RL		 1443 OPT_COMMANDS, OPT_DIGEST_COMMANDS, OPT_MAC_ALGORITHMS, OPT_OPTIONS,
1444 OPT_DIGEST_ALGORITHMS, OPT_CIPHER_COMMANDS, OPT_CIPHER_ALGORITHMS,
0a684b09 1445 OPT_PK_ALGORITHMS, OPT_PK_METHOD, OPT_DISABLED,
2ff4e15d 1446 OPT_KDF_ALGORITHMS, OPT_RANDOM_INSTANCES, OPT_RANDOM_GENERATORS,
fc959d71
SL		 1447 OPT_ENCODERS, OPT_DECODERS, OPT_KEYMANAGERS, OPT_KEYEXCHANGE_ALGORITHMS,
1448 OPT_KEM_ALGORITHMS, OPT_SIGNATURE_ALGORITHMS, OPT_ASYM_CIPHER_ALGORITHMS,
e0113b79 1449 OPT_STORE_LOADERS, OPT_PROVIDER_INFO,
25fad2ec 1450 OPT_OBJECTS, OPT_SELECT_NAME,
0a684b09
P		 1451#ifndef OPENSSL_NO_DEPRECATED_3_0
1452 OPT_ENGINES,
1453#endif
6bd4e3f2 1454 OPT_PROV_ENUM
753149d9
RL		 1455} HELPLIST_CHOICE;
1456
1457const OPTIONS list_options[] = {
5388f986
RS		 1458
1459 OPT_SECTION("General"),
753149d9 1460 {"help", OPT_HELP, '-', "Display this summary"},
5388f986
RS		 1461
1462 OPT_SECTION("Output"),
753149d9 1463 {"1", OPT_ONE, '-', "List in one column"},
ad623ec0 1464 {"verbose", OPT_VERBOSE, '-', "Verbose listing"},
fc959d71 1465 {"select", OPT_SELECT_NAME, 's', "Select a single algorithm"},
753149d9 1466 {"commands", OPT_COMMANDS, '-', "List of standard commands"},
d333c311 1467 {"standard-commands", OPT_COMMANDS, '-', "List of standard commands"},
35b67070 1468 {"all-algorithms", OPT_ALL_ARGORITHMS, '-', "List of all algorithms"},
cb75a155 1469#ifndef OPENSSL_NO_DEPRECATED_3_0
753149d9 1470 {"digest-commands", OPT_DIGEST_COMMANDS, '-',
cb75a155
DB		 1471 "List of message digest commands (deprecated)"},
1472#endif
753149d9
RL		 1473 {"digest-algorithms", OPT_DIGEST_ALGORITHMS, '-',
1474 "List of message digest algorithms"},
55accfd2
P		 1475 {"kdf-algorithms", OPT_KDF_ALGORITHMS, '-',
1476 "List of key derivation and pseudo random function algorithms"},
2ff4e15d 1477 {"random-instances", OPT_RANDOM_INSTANCES, '-',
78c44e4f 1478 "List the primary, public and private random number generator details"},
2dee33df 1479 {"random-generators", OPT_RANDOM_GENERATORS, '-',
ece9304c 1480 "List of random number generators"},
753149d9
RL		 1481 {"mac-algorithms", OPT_MAC_ALGORITHMS, '-',
1482 "List of message authentication code algorithms"},
cb75a155
DB		 1483#ifndef OPENSSL_NO_DEPRECATED_3_0
1484 {"cipher-commands", OPT_CIPHER_COMMANDS, '-',
1485 "List of cipher commands (deprecated)"},
1486#endif
753149d9 1487 {"cipher-algorithms", OPT_CIPHER_ALGORITHMS, '-',
2eb75291 1488 "List of symmetric cipher algorithms"},
ece9304c
RL		 1489 {"encoders", OPT_ENCODERS, '-', "List of encoding methods" },
1490 {"decoders", OPT_DECODERS, '-', "List of decoding methods" },
fc959d71
SL		 1491 {"key-managers", OPT_KEYMANAGERS, '-', "List of key managers" },
1492 {"key-exchange-algorithms", OPT_KEYEXCHANGE_ALGORITHMS, '-',
1493 "List of key exchange algorithms" },
1494 {"kem-algorithms", OPT_KEM_ALGORITHMS, '-',
1495 "List of key encapsulation mechanism algorithms" },
1496 {"signature-algorithms", OPT_SIGNATURE_ALGORITHMS, '-',
1497 "List of signature algorithms" },
78c44e4f 1498 {"asymcipher-algorithms", OPT_ASYM_CIPHER_ALGORITHMS, '-',
fc959d71 1499 "List of asymmetric cipher algorithms" },
753149d9
RL		 1500 {"public-key-algorithms", OPT_PK_ALGORITHMS, '-',
1501 "List of public key algorithms"},
1502 {"public-key-methods", OPT_PK_METHOD, '-',
1503 "List of public key methods"},
e0113b79
P		 1504 {"store-loaders", OPT_STORE_LOADERS, '-',
1505 "List of store loaders"},
f4bd5105
P		 1506 {"providers", OPT_PROVIDER_INFO, '-',
1507 "List of provider information"},
fc959d71 1508#ifndef OPENSSL_NO_DEPRECATED_3_0
753149d9
RL		 1509 {"engines", OPT_ENGINES, '-',
1510 "List of loaded engines"},
0a684b09 1511#endif
dfc0857d 1512 {"disabled", OPT_DISABLED, '-', "List of disabled features"},
753149d9
RL		 1513 {"options", OPT_OPTIONS, 's',
1514 "List options for specified command"},
1515 {"objects", OPT_OBJECTS, '-',
1516 "List built in objects (OID<->name mappings)"},
6bd4e3f2
P		 1517
1518 OPT_PROV_OPTIONS,
753149d9
RL		 1519 {NULL}
1520};
1521
1522int list_main(int argc, char **argv)
1523{
1524 char *prog;
1525 HELPLIST_CHOICE o;
1526 int one = 0, done = 0;
ec1d5970 1527 int print_newline = 0;
ad623ec0
RL		 1528 struct {
1529 unsigned int commands:1;
35b67070 1530 unsigned int all_algorithms:1;
2ff4e15d 1531 unsigned int random_instances:1;
2dee33df 1532 unsigned int random_generators:1;
ad623ec0
RL		 1533 unsigned int digest_commands:1;
1534 unsigned int digest_algorithms:1;
55accfd2 1535 unsigned int kdf_algorithms:1;
ad623ec0
RL		 1536 unsigned int mac_algorithms:1;
1537 unsigned int cipher_commands:1;
1538 unsigned int cipher_algorithms:1;
ece9304c
RL		 1539 unsigned int encoder_algorithms:1;
1540 unsigned int decoder_algorithms:1;
fc959d71
SL		 1541 unsigned int keymanager_algorithms:1;
1542 unsigned int signature_algorithms:1;
1543 unsigned int keyexchange_algorithms:1;
1544 unsigned int kem_algorithms:1;
1545 unsigned int asym_cipher_algorithms:1;
ad623ec0
RL		 1546 unsigned int pk_algorithms:1;
1547 unsigned int pk_method:1;
e0113b79 1548 unsigned int store_loaders:1;
f4bd5105 1549 unsigned int provider_info:1;
0a684b09 1550#ifndef OPENSSL_NO_DEPRECATED_3_0
ad623ec0 1551 unsigned int engines:1;
0a684b09 1552#endif
ad623ec0 1553 unsigned int disabled:1;
ad623ec0
RL		 1554 unsigned int objects:1;
1555 unsigned int options:1;
1556 } todo = { 0, };
1557
1558 verbose = 0; /* Clear a possible previous call */
753149d9
RL		 1559
1560 prog = opt_init(argc, argv, list_options);
1561 while ((o = opt_next()) != OPT_EOF) {
1562 switch (o) {
1563 case OPT_EOF: /* Never hit, but suppresses warning */
1564 case OPT_ERR:
1565opthelp:
1566 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1567 return 1;
1568 case OPT_HELP:
1569 opt_help(list_options);
b5d984bf 1570 return 0;
753149d9
RL		 1571 case OPT_ONE:
1572 one = 1;
1573 break;
35b67070
P		 1574 case OPT_ALL_ARGORITHMS:
1575 todo.all_algorithms = 1;
1576 break;
753149d9 1577 case OPT_COMMANDS:
ad623ec0 1578 todo.commands = 1;
753149d9
RL		 1579 break;
1580 case OPT_DIGEST_COMMANDS:
ad623ec0 1581 todo.digest_commands = 1;
753149d9
RL		 1582 break;
1583 case OPT_DIGEST_ALGORITHMS:
ad623ec0 1584 todo.digest_algorithms = 1;
753149d9 1585 break;
55accfd2
P		 1586 case OPT_KDF_ALGORITHMS:
1587 todo.kdf_algorithms = 1;
1588 break;
2ff4e15d
P		 1589 case OPT_RANDOM_INSTANCES:
1590 todo.random_instances = 1;
1591 break;
2dee33df
P		 1592 case OPT_RANDOM_GENERATORS:
1593 todo.random_generators = 1;
1594 break;
753149d9 1595 case OPT_MAC_ALGORITHMS:
ad623ec0 1596 todo.mac_algorithms = 1;
753149d9
RL		 1597 break;
1598 case OPT_CIPHER_COMMANDS:
ad623ec0 1599 todo.cipher_commands = 1;
753149d9
RL		 1600 break;
1601 case OPT_CIPHER_ALGORITHMS:
ad623ec0 1602 todo.cipher_algorithms = 1;
753149d9 1603 break;
ece9304c
RL		 1604 case OPT_ENCODERS:
1605 todo.encoder_algorithms = 1;
dfc0857d 1606 break;
ece9304c
RL		 1607 case OPT_DECODERS:
1608 todo.decoder_algorithms = 1;
a3f15e23 1609 break;
fc959d71
SL		 1610 case OPT_KEYMANAGERS:
1611 todo.keymanager_algorithms = 1;
1612 break;
1613 case OPT_SIGNATURE_ALGORITHMS:
1614 todo.signature_algorithms = 1;
1615 break;
1616 case OPT_KEYEXCHANGE_ALGORITHMS:
1617 todo.keyexchange_algorithms = 1;
1618 break;
1619 case OPT_KEM_ALGORITHMS:
1620 todo.kem_algorithms = 1;
1621 break;
1622 case OPT_ASYM_CIPHER_ALGORITHMS:
1623 todo.asym_cipher_algorithms = 1;
1624 break;
753149d9 1625 case OPT_PK_ALGORITHMS:
ad623ec0 1626 todo.pk_algorithms = 1;
753149d9
RL		 1627 break;
1628 case OPT_PK_METHOD:
ad623ec0 1629 todo.pk_method = 1;
753149d9 1630 break;
e0113b79
P		 1631 case OPT_STORE_LOADERS:
1632 todo.store_loaders = 1;
1633 break;
f4bd5105
P		 1634 case OPT_PROVIDER_INFO:
1635 todo.provider_info = 1;
1636 break;
0a684b09 1637#ifndef OPENSSL_NO_DEPRECATED_3_0
753149d9 1638 case OPT_ENGINES:
ad623ec0 1639 todo.engines = 1;
753149d9 1640 break;
0a684b09 1641#endif
753149d9 1642 case OPT_DISABLED:
ad623ec0 1643 todo.disabled = 1;
753149d9 1644 break;
753149d9 1645 case OPT_OBJECTS:
ad623ec0 1646 todo.objects = 1;
753149d9
RL		 1647 break;
1648 case OPT_OPTIONS:
1649 list_options_for_command(opt_arg());
1650 break;
ad623ec0
RL		 1651 case OPT_VERBOSE:
1652 verbose = 1;
1653 break;
fc959d71
SL		 1654 case OPT_SELECT_NAME:
1655 select_name = opt_arg();
1656 break;
6bd4e3f2
P		 1657 case OPT_PROV_CASES:
1658 if (!opt_provider(o))
1659 return 1;
1660 break;
753149d9
RL		 1661 }
1662 done = 1;
1663 }
021410ea
RS		 1664
1665 /* No extra arguments. */
d9f07357 1666 if (!opt_check_rest_arg(NULL))
753149d9 1667 goto opthelp;
753149d9 1668
ec1d5970
DF		 1669#define MAYBE_ADD_NL(cmd) \
1670 do { \
1671 if (print_newline++) { \
1672 BIO_printf(bio_out, "\n"); \
1673 } \
1674 cmd; \
1675 } while(0)
1676
ad623ec0 1677 if (todo.commands)
ec1d5970 1678 MAYBE_ADD_NL(list_type(FT_general, one));
35b67070 1679 if (todo.all_algorithms) {
ec1d5970
DF		 1680 MAYBE_ADD_NL({});
1681
35b67070
P		 1682 BIO_printf(bio_out, "Digests:\n");
1683 list_digests(" ");
ec1d5970 1684 BIO_printf(bio_out, "\nSymmetric Ciphers:\n");
35b67070 1685 list_ciphers(" ");
ec1d5970 1686 BIO_printf(bio_out, "\n");
35b67070 1687 list_kdfs();
ec1d5970 1688 BIO_printf(bio_out, "\n");
35b67070
P		 1689 list_macs();
1690
ec1d5970 1691 BIO_printf(bio_out, "\nProvided Asymmetric Encryption:\n");
35b67070 1692 list_asymciphers();
ec1d5970 1693 BIO_printf(bio_out, "\nProvided Key Exchange:\n");
35b67070 1694 list_keyexchanges();
ec1d5970 1695 BIO_printf(bio_out, "\nProvided Signatures:\n");
35b67070 1696 list_signatures();
ec1d5970 1697 BIO_printf(bio_out, "\nProvided Key encapsulation:\n");
35b67070 1698 list_kems();
ec1d5970 1699 BIO_printf(bio_out, "\nProvided Key managers:\n");
35b67070
P		 1700 list_keymanagers();
1701
ec1d5970 1702 BIO_printf(bio_out, "\n");
35b67070 1703 list_encoders();
ec1d5970 1704 BIO_printf(bio_out, "\n");
35b67070 1705 list_decoders();
ec1d5970 1706 BIO_printf(bio_out, "\n");
35b67070
P		 1707 list_store_loaders();
1708 }
2ff4e15d 1709 if (todo.random_instances)
ec1d5970 1710 MAYBE_ADD_NL(list_random_instances());
2dee33df 1711 if (todo.random_generators)
ec1d5970 1712 MAYBE_ADD_NL(list_random_generators());
ad623ec0 1713 if (todo.digest_commands)
ec1d5970 1714 MAYBE_ADD_NL(list_type(FT_md, one));
ad623ec0 1715 if (todo.digest_algorithms)
ec1d5970 1716 MAYBE_ADD_NL(list_digests(""));
55accfd2 1717 if (todo.kdf_algorithms)
ec1d5970 1718 MAYBE_ADD_NL(list_kdfs());
ad623ec0 1719 if (todo.mac_algorithms)
ec1d5970 1720 MAYBE_ADD_NL(list_macs());
ad623ec0 1721 if (todo.cipher_commands)
ec1d5970 1722 MAYBE_ADD_NL(list_type(FT_cipher, one));
ad623ec0 1723 if (todo.cipher_algorithms)
ec1d5970 1724 MAYBE_ADD_NL(list_ciphers(""));
ece9304c 1725 if (todo.encoder_algorithms)
ec1d5970 1726 MAYBE_ADD_NL(list_encoders());
ece9304c 1727 if (todo.decoder_algorithms)
ec1d5970 1728 MAYBE_ADD_NL(list_decoders());
fc959d71 1729 if (todo.keymanager_algorithms)
ec1d5970 1730 MAYBE_ADD_NL(list_keymanagers());
fc959d71 1731 if (todo.signature_algorithms)
ec1d5970 1732 MAYBE_ADD_NL(list_signatures());
fc959d71 1733 if (todo.asym_cipher_algorithms)
ec1d5970 1734 MAYBE_ADD_NL(list_asymciphers());
fc959d71 1735 if (todo.keyexchange_algorithms)
ec1d5970 1736 MAYBE_ADD_NL(list_keyexchanges());
fc959d71 1737 if (todo.kem_algorithms)
ec1d5970 1738 MAYBE_ADD_NL(list_kems());
ad623ec0 1739 if (todo.pk_algorithms)
ec1d5970 1740 MAYBE_ADD_NL(list_pkey());
ad623ec0 1741 if (todo.pk_method)
ec1d5970 1742 MAYBE_ADD_NL(list_pkey_meth());
e0113b79 1743 if (todo.store_loaders)
ec1d5970 1744 MAYBE_ADD_NL(list_store_loaders());
f4bd5105 1745 if (todo.provider_info)
ec1d5970 1746 MAYBE_ADD_NL(list_provider_info());
fc959d71 1747#ifndef OPENSSL_NO_DEPRECATED_3_0
ad623ec0 1748 if (todo.engines)
ec1d5970 1749 MAYBE_ADD_NL(list_engines());
0a684b09 1750#endif
ad623ec0 1751 if (todo.disabled)
ec1d5970 1752 MAYBE_ADD_NL(list_disabled());
ad623ec0 1753 if (todo.objects)
ec1d5970
DF		 1754 MAYBE_ADD_NL(list_objects());
1755
1756#undef MAYBE_ADD_NL
ad623ec0 1757
753149d9
RL		 1758 if (!done)
1759 goto opthelp;
1760
1761 return 0;
1762}
A mirror of the official openssl repository