1 /*
2 * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the Apache License 2.0 (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10 /* We need to use some deprecated APIs */
11 #define OPENSSL_SUPPRESS_DEPRECATED
12
13 #include <string.h>
14 #include <openssl/evp.h>
15 #include <openssl/err.h>
16 #include <openssl/provider.h>
17 #include <openssl/safestack.h>
18 #include <openssl/kdf.h>
19 #include <openssl/encoder.h>
20 #include <openssl/decoder.h>
21 #include <openssl/store.h>
22 #include <openssl/core_names.h>
23 #include <openssl/rand.h>
24 #include "apps.h"
25 #include "app_params.h"
26 #include "progs.h"
27 #include "opt.h"
28 #include "names.h"
29
30 static int verbose = 0;
31 static const char *select_name = NULL;
32
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(); \
39 OSSL_LIB_CTX *libctx = app_get0_libctx(); \
40 const char *name = TYPE ## _get0_name(alg); \
41 \
42 ERR_set_mark(); \
43 impl = TYPE ## _fetch(libctx, name, propq); \
44 ERR_pop_to_mark(); \
45 if (impl == NULL) \
46 return 0; \
47 TYPE ## _free(impl); \
48 return 1; \
49 }
IS_FETCHABLE(cipher,EVP_CIPHER)50 IS_FETCHABLE(cipher, EVP_CIPHER)
51 IS_FETCHABLE(digest, EVP_MD)
52 IS_FETCHABLE(mac, EVP_MAC)
53 IS_FETCHABLE(kdf, EVP_KDF)
54 IS_FETCHABLE(rand, EVP_RAND)
55 IS_FETCHABLE(keymgmt, EVP_KEYMGMT)
56 IS_FETCHABLE(signature, EVP_SIGNATURE)
57 IS_FETCHABLE(kem, EVP_KEM)
58 IS_FETCHABLE(asym_cipher, EVP_ASYM_CIPHER)
59 IS_FETCHABLE(keyexch, EVP_KEYEXCH)
60 IS_FETCHABLE(decoder, OSSL_DECODER)
61 IS_FETCHABLE(encoder, OSSL_ENCODER)
62
63 #ifndef OPENSSL_NO_DEPRECATED_3_0
64 static int include_legacy(void)
65 {
66 return app_get0_propq() == NULL;
67 }
68
legacy_cipher_fn(const EVP_CIPHER * c,const char * from,const char * to,void * arg)69 static void legacy_cipher_fn(const EVP_CIPHER *c,
70 const char *from, const char *to, void *arg)
71 {
72 if (select_name != NULL
73 && (c == NULL
74 || OPENSSL_strcasecmp(select_name, EVP_CIPHER_get0_name(c)) != 0))
75 return;
76 if (c != NULL) {
77 BIO_printf(arg, " %s\n", EVP_CIPHER_get0_name(c));
78 } else {
79 if (from == NULL)
80 from = "<undefined>";
81 if (to == NULL)
82 to = "<undefined>";
83 BIO_printf(arg, " %s => %s\n", from, to);
84 }
85 }
86 #endif
87
DEFINE_STACK_OF(EVP_CIPHER)88 DEFINE_STACK_OF(EVP_CIPHER)
89 static int cipher_cmp(const EVP_CIPHER * const *a,
90 const EVP_CIPHER * const *b)
91 {
92 return strcmp(OSSL_PROVIDER_get0_name(EVP_CIPHER_get0_provider(*a)),
93 OSSL_PROVIDER_get0_name(EVP_CIPHER_get0_provider(*b)));
94 }
95
collect_ciphers(EVP_CIPHER * cipher,void * stack)96 static void collect_ciphers(EVP_CIPHER *cipher, void *stack)
97 {
98 STACK_OF(EVP_CIPHER) *cipher_stack = stack;
99
100 if (is_cipher_fetchable(cipher)
101 && sk_EVP_CIPHER_push(cipher_stack, cipher) > 0)
102 EVP_CIPHER_up_ref(cipher);
103 }
104
list_ciphers(void)105 static void list_ciphers(void)
106 {
107 STACK_OF(EVP_CIPHER) *ciphers = sk_EVP_CIPHER_new(cipher_cmp);
108 int i;
109
110 if (ciphers == NULL) {
111 BIO_printf(bio_err, "ERROR: Memory allocation\n");
112 return;
113 }
114 #ifndef OPENSSL_NO_DEPRECATED_3_0
115 if (include_legacy()) {
116 BIO_printf(bio_out, "Legacy:\n");
117 EVP_CIPHER_do_all_sorted(legacy_cipher_fn, bio_out);
118 }
119 #endif
120
121 BIO_printf(bio_out, "Provided:\n");
122 EVP_CIPHER_do_all_provided(app_get0_libctx(), collect_ciphers, ciphers);
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);
126 STACK_OF(OPENSSL_CSTRING) *names = NULL;
127
128 if (select_name != NULL && !EVP_CIPHER_is_a(c, select_name))
129 continue;
130
131 names = sk_OPENSSL_CSTRING_new(name_cmp);
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",
137 OSSL_PROVIDER_get0_name(EVP_CIPHER_get0_provider(c)));
138
139 if (verbose) {
140 const char *desc = EVP_CIPHER_get0_description(c);
141
142 if (desc != NULL)
143 BIO_printf(bio_out, " description: %s\n", desc);
144 print_param_types("retrievable algorithm parameters",
145 EVP_CIPHER_gettable_params(c), 4);
146 print_param_types("retrievable operation parameters",
147 EVP_CIPHER_gettable_ctx_params(c), 4);
148 print_param_types("settable operation parameters",
149 EVP_CIPHER_settable_ctx_params(c), 4);
150 }
151 }
152 sk_OPENSSL_CSTRING_free(names);
153 }
154 sk_EVP_CIPHER_pop_free(ciphers, EVP_CIPHER_free);
155 }
156
157 #ifndef OPENSSL_NO_DEPRECATED_3_0
legacy_md_fn(const EVP_MD * m,const char * from,const char * to,void * arg)158 static void legacy_md_fn(const EVP_MD *m,
159 const char *from, const char *to, void *arg)
160 {
161 if (m != NULL) {
162 BIO_printf(arg, " %s\n", EVP_MD_get0_name(m));
163 } else {
164 if (from == NULL)
165 from = "<undefined>";
166 if (to == NULL)
167 to = "<undefined>";
168 BIO_printf((BIO *)arg, " %s => %s\n", from, to);
169 }
170 }
171 #endif
172
DEFINE_STACK_OF(EVP_MD)173 DEFINE_STACK_OF(EVP_MD)
174 static int md_cmp(const EVP_MD * const *a, const EVP_MD * const *b)
175 {
176 return strcmp(OSSL_PROVIDER_get0_name(EVP_MD_get0_provider(*a)),
177 OSSL_PROVIDER_get0_name(EVP_MD_get0_provider(*b)));
178 }
179
collect_digests(EVP_MD * digest,void * stack)180 static void collect_digests(EVP_MD *digest, void *stack)
181 {
182 STACK_OF(EVP_MD) *digest_stack = stack;
183
184 if (is_digest_fetchable(digest)
185 && sk_EVP_MD_push(digest_stack, digest) > 0)
186 EVP_MD_up_ref(digest);
187 }
188
list_digests(void)189 static void list_digests(void)
190 {
191 STACK_OF(EVP_MD) *digests = sk_EVP_MD_new(md_cmp);
192 int i;
193
194 if (digests == NULL) {
195 BIO_printf(bio_err, "ERROR: Memory allocation\n");
196 return;
197 }
198 #ifndef OPENSSL_NO_DEPRECATED_3_0
199 if (include_legacy()) {
200 BIO_printf(bio_out, "Legacy:\n");
201 EVP_MD_do_all_sorted(legacy_md_fn, bio_out);
202 }
203 #endif
204
205 BIO_printf(bio_out, "Provided:\n");
206 EVP_MD_do_all_provided(app_get0_libctx(), collect_digests, digests);
207 sk_EVP_MD_sort(digests);
208 for (i = 0; i < sk_EVP_MD_num(digests); i++) {
209 const EVP_MD *m = sk_EVP_MD_value(digests, i);
210 STACK_OF(OPENSSL_CSTRING) *names = NULL;
211
212 if (select_name != NULL && !EVP_MD_is_a(m, select_name))
213 continue;
214
215 names = sk_OPENSSL_CSTRING_new(name_cmp);
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
220 BIO_printf(bio_out, " @ %s\n",
221 OSSL_PROVIDER_get0_name(EVP_MD_get0_provider(m)));
222
223 if (verbose) {
224 const char *desc = EVP_MD_get0_description(m);
225
226 if (desc != NULL)
227 BIO_printf(bio_out, " description: %s\n", desc);
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 }
235 }
236 sk_OPENSSL_CSTRING_free(names);
237 }
238 sk_EVP_MD_pop_free(digests, EVP_MD_free);
239 }
240
DEFINE_STACK_OF(EVP_MAC)241 DEFINE_STACK_OF(EVP_MAC)
242 static int mac_cmp(const EVP_MAC * const *a, const EVP_MAC * const *b)
243 {
244 return strcmp(OSSL_PROVIDER_get0_name(EVP_MAC_get0_provider(*a)),
245 OSSL_PROVIDER_get0_name(EVP_MAC_get0_provider(*b)));
246 }
247
collect_macs(EVP_MAC * mac,void * stack)248 static void collect_macs(EVP_MAC *mac, void *stack)
249 {
250 STACK_OF(EVP_MAC) *mac_stack = stack;
251
252 if (is_mac_fetchable(mac)
253 && sk_EVP_MAC_push(mac_stack, mac) > 0)
254 EVP_MAC_up_ref(mac);
255 }
256
list_macs(void)257 static void list_macs(void)
258 {
259 STACK_OF(EVP_MAC) *macs = sk_EVP_MAC_new(mac_cmp);
260 int i;
261
262 if (macs == NULL) {
263 BIO_printf(bio_err, "ERROR: Memory allocation\n");
264 return;
265 }
266 BIO_printf(bio_out, "Provided MACs:\n");
267 EVP_MAC_do_all_provided(app_get0_libctx(), collect_macs, macs);
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);
271 STACK_OF(OPENSSL_CSTRING) *names = NULL;
272
273 if (select_name != NULL && !EVP_MAC_is_a(m, select_name))
274 continue;
275
276 names = sk_OPENSSL_CSTRING_new(name_cmp);
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
281 BIO_printf(bio_out, " @ %s\n",
282 OSSL_PROVIDER_get0_name(EVP_MAC_get0_provider(m)));
283
284 if (verbose) {
285 const char *desc = EVP_MAC_get0_description(m);
286
287 if (desc != NULL)
288 BIO_printf(bio_out, " description: %s\n", desc);
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 }
296 }
297 sk_OPENSSL_CSTRING_free(names);
298 }
299 sk_EVP_MAC_pop_free(macs, EVP_MAC_free);
300 }
301
302 /*
303 * KDFs and PRFs
304 */
DEFINE_STACK_OF(EVP_KDF)305 DEFINE_STACK_OF(EVP_KDF)
306 static int kdf_cmp(const EVP_KDF * const *a, const EVP_KDF * const *b)
307 {
308 return strcmp(OSSL_PROVIDER_get0_name(EVP_KDF_get0_provider(*a)),
309 OSSL_PROVIDER_get0_name(EVP_KDF_get0_provider(*b)));
310 }
311
collect_kdfs(EVP_KDF * kdf,void * stack)312 static void collect_kdfs(EVP_KDF *kdf, void *stack)
313 {
314 STACK_OF(EVP_KDF) *kdf_stack = stack;
315
316 if (is_kdf_fetchable(kdf)
317 && sk_EVP_KDF_push(kdf_stack, kdf) > 0)
318 EVP_KDF_up_ref(kdf);
319 }
320
list_kdfs(void)321 static void list_kdfs(void)
322 {
323 STACK_OF(EVP_KDF) *kdfs = sk_EVP_KDF_new(kdf_cmp);
324 int i;
325
326 if (kdfs == NULL) {
327 BIO_printf(bio_err, "ERROR: Memory allocation\n");
328 return;
329 }
330 BIO_printf(bio_out, "Provided KDFs and PDFs:\n");
331 EVP_KDF_do_all_provided(app_get0_libctx(), collect_kdfs, kdfs);
332 sk_EVP_KDF_sort(kdfs);
333 for (i = 0; i < sk_EVP_KDF_num(kdfs); i++) {
334 const EVP_KDF *k = sk_EVP_KDF_value(kdfs, i);
335 STACK_OF(OPENSSL_CSTRING) *names = NULL;
336
337 if (select_name != NULL && !EVP_KDF_is_a(k, select_name))
338 continue;
339
340 names = sk_OPENSSL_CSTRING_new(name_cmp);
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
345 BIO_printf(bio_out, " @ %s\n",
346 OSSL_PROVIDER_get0_name(EVP_KDF_get0_provider(k)));
347
348 if (verbose) {
349 const char *desc = EVP_KDF_get0_description(k);
350
351 if (desc != NULL)
352 BIO_printf(bio_out, " description: %s\n", desc);
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 }
360 }
361 sk_OPENSSL_CSTRING_free(names);
362 }
363 sk_EVP_KDF_pop_free(kdfs, EVP_KDF_free);
364 }
365
366 /*
367 * RANDs
368 */
DEFINE_STACK_OF(EVP_RAND)369 DEFINE_STACK_OF(EVP_RAND)
370
371 static int rand_cmp(const EVP_RAND * const *a, const EVP_RAND * const *b)
372 {
373 int ret = OPENSSL_strcasecmp(EVP_RAND_get0_name(*a), EVP_RAND_get0_name(*b));
374
375 if (ret == 0)
376 ret = strcmp(OSSL_PROVIDER_get0_name(EVP_RAND_get0_provider(*a)),
377 OSSL_PROVIDER_get0_name(EVP_RAND_get0_provider(*b)));
378
379 return ret;
380 }
381
collect_rands(EVP_RAND * rand,void * stack)382 static void collect_rands(EVP_RAND *rand, void *stack)
383 {
384 STACK_OF(EVP_RAND) *rand_stack = stack;
385
386 if (is_rand_fetchable(rand)
387 && sk_EVP_RAND_push(rand_stack, rand) > 0)
388 EVP_RAND_up_ref(rand);
389 }
390
list_random_generators(void)391 static 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");
401 EVP_RAND_do_all_provided(app_get0_libctx(), collect_rands, rands);
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
406 if (select_name != NULL
407 && OPENSSL_strcasecmp(EVP_RAND_get0_name(m), select_name) != 0)
408 continue;
409 BIO_printf(bio_out, " %s", EVP_RAND_get0_name(m));
410 BIO_printf(bio_out, " @ %s\n",
411 OSSL_PROVIDER_get0_name(EVP_RAND_get0_provider(m)));
412
413 if (verbose) {
414 const char *desc = EVP_RAND_get0_description(m);
415
416 if (desc != NULL)
417 BIO_printf(bio_out, " description: %s\n", desc);
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
display_random(const char * name,EVP_RAND_CTX * drbg)429 static 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) {
440 rand = EVP_RAND_CTX_get0_rand(drbg);
441
442 BIO_printf(bio_out, " %s", EVP_RAND_get0_name(rand));
443 BIO_printf(bio_out, " @ %s\n",
444 OSSL_PROVIDER_get0_name(EVP_RAND_get0_provider(rand)));
445
446 switch (EVP_RAND_get_state(drbg)) {
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 */
466 if (OPENSSL_strcasecmp(gettables->key, OSSL_RAND_PARAM_STATE) == 0)
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;
484 if (EVP_RAND_CTX_get_params(drbg, params))
485 print_param_value(params, 2);
486 }
487 }
488 }
489
list_random_instances(void)490 static 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
497 /*
498 * Encoders
499 */
DEFINE_STACK_OF(OSSL_ENCODER)500 DEFINE_STACK_OF(OSSL_ENCODER)
501 static int encoder_cmp(const OSSL_ENCODER * const *a,
502 const OSSL_ENCODER * const *b)
503 {
504 return strcmp(OSSL_PROVIDER_get0_name(OSSL_ENCODER_get0_provider(*a)),
505 OSSL_PROVIDER_get0_name(OSSL_ENCODER_get0_provider(*b)));
506 }
507
collect_encoders(OSSL_ENCODER * encoder,void * stack)508 static void collect_encoders(OSSL_ENCODER *encoder, void *stack)
509 {
510 STACK_OF(OSSL_ENCODER) *encoder_stack = stack;
511
512 if (is_encoder_fetchable(encoder)
513 && sk_OSSL_ENCODER_push(encoder_stack, encoder) > 0)
514 OSSL_ENCODER_up_ref(encoder);
515 }
516
list_encoders(void)517 static void list_encoders(void)
518 {
519 STACK_OF(OSSL_ENCODER) *encoders;
520 int i;
521
522 encoders = sk_OSSL_ENCODER_new(encoder_cmp);
523 if (encoders == NULL) {
524 BIO_printf(bio_err, "ERROR: Memory allocation\n");
525 return;
526 }
527 BIO_printf(bio_out, "Provided ENCODERs:\n");
528 OSSL_ENCODER_do_all_provided(app_get0_libctx(), collect_encoders,
529 encoders);
530 sk_OSSL_ENCODER_sort(encoders);
531
532 for (i = 0; i < sk_OSSL_ENCODER_num(encoders); i++) {
533 OSSL_ENCODER *k = sk_OSSL_ENCODER_value(encoders, i);
534 STACK_OF(OPENSSL_CSTRING) *names = NULL;
535
536 if (select_name != NULL && !OSSL_ENCODER_is_a(k, select_name))
537 continue;
538
539 names = sk_OPENSSL_CSTRING_new(name_cmp);
540 if (names != NULL && OSSL_ENCODER_names_do_all(k, collect_names, names)) {
541 BIO_printf(bio_out, " ");
542 print_names(bio_out, names);
543
544 BIO_printf(bio_out, " @ %s (%s)\n",
545 OSSL_PROVIDER_get0_name(OSSL_ENCODER_get0_provider(k)),
546 OSSL_ENCODER_get0_properties(k));
547
548 if (verbose) {
549 const char *desc = OSSL_ENCODER_get0_description(k);
550
551 if (desc != NULL)
552 BIO_printf(bio_out, " description: %s\n", desc);
553 print_param_types("settable operation parameters",
554 OSSL_ENCODER_settable_ctx_params(k), 4);
555 }
556 }
557 sk_OPENSSL_CSTRING_free(names);
558 }
559 sk_OSSL_ENCODER_pop_free(encoders, OSSL_ENCODER_free);
560 }
561
562 /*
563 * Decoders
564 */
DEFINE_STACK_OF(OSSL_DECODER)565 DEFINE_STACK_OF(OSSL_DECODER)
566 static int decoder_cmp(const OSSL_DECODER * const *a,
567 const OSSL_DECODER * const *b)
568 {
569 return strcmp(OSSL_PROVIDER_get0_name(OSSL_DECODER_get0_provider(*a)),
570 OSSL_PROVIDER_get0_name(OSSL_DECODER_get0_provider(*b)));
571 }
572
collect_decoders(OSSL_DECODER * decoder,void * stack)573 static void collect_decoders(OSSL_DECODER *decoder, void *stack)
574 {
575 STACK_OF(OSSL_DECODER) *decoder_stack = stack;
576
577 if (is_decoder_fetchable(decoder)
578 && sk_OSSL_DECODER_push(decoder_stack, decoder) > 0)
579 OSSL_DECODER_up_ref(decoder);
580 }
581
list_decoders(void)582 static void list_decoders(void)
583 {
584 STACK_OF(OSSL_DECODER) *decoders;
585 int i;
586
587 decoders = sk_OSSL_DECODER_new(decoder_cmp);
588 if (decoders == NULL) {
589 BIO_printf(bio_err, "ERROR: Memory allocation\n");
590 return;
591 }
592 BIO_printf(bio_out, "Provided DECODERs:\n");
593 OSSL_DECODER_do_all_provided(app_get0_libctx(), collect_decoders,
594 decoders);
595 sk_OSSL_DECODER_sort(decoders);
596
597 for (i = 0; i < sk_OSSL_DECODER_num(decoders); i++) {
598 OSSL_DECODER *k = sk_OSSL_DECODER_value(decoders, i);
599 STACK_OF(OPENSSL_CSTRING) *names = NULL;
600
601 if (select_name != NULL && !OSSL_DECODER_is_a(k, select_name))
602 continue;
603
604 names = sk_OPENSSL_CSTRING_new(name_cmp);
605 if (names != NULL && OSSL_DECODER_names_do_all(k, collect_names, names)) {
606 BIO_printf(bio_out, " ");
607 print_names(bio_out, names);
608
609 BIO_printf(bio_out, " @ %s (%s)\n",
610 OSSL_PROVIDER_get0_name(OSSL_DECODER_get0_provider(k)),
611 OSSL_DECODER_get0_properties(k));
612
613 if (verbose) {
614 const char *desc = OSSL_DECODER_get0_description(k);
615
616 if (desc != NULL)
617 BIO_printf(bio_out, " description: %s\n", desc);
618 print_param_types("settable operation parameters",
619 OSSL_DECODER_settable_ctx_params(k), 4);
620 }
621 }
622 sk_OPENSSL_CSTRING_free(names);
623 }
624 sk_OSSL_DECODER_pop_free(decoders, OSSL_DECODER_free);
625 }
626
DEFINE_STACK_OF(EVP_KEYMGMT)627 DEFINE_STACK_OF(EVP_KEYMGMT)
628 static int keymanager_cmp(const EVP_KEYMGMT * const *a,
629 const EVP_KEYMGMT * const *b)
630 {
631 return strcmp(OSSL_PROVIDER_get0_name(EVP_KEYMGMT_get0_provider(*a)),
632 OSSL_PROVIDER_get0_name(EVP_KEYMGMT_get0_provider(*b)));
633 }
634
collect_keymanagers(EVP_KEYMGMT * km,void * stack)635 static void collect_keymanagers(EVP_KEYMGMT *km, void *stack)
636 {
637 STACK_OF(EVP_KEYMGMT) *km_stack = stack;
638
639 if (is_keymgmt_fetchable(km)
640 && sk_EVP_KEYMGMT_push(km_stack, km) > 0)
641 EVP_KEYMGMT_up_ref(km);
642 }
643
list_keymanagers(void)644 static void list_keymanagers(void)
645 {
646 int i;
647 STACK_OF(EVP_KEYMGMT) *km_stack = sk_EVP_KEYMGMT_new(keymanager_cmp);
648
649 EVP_KEYMGMT_do_all_provided(app_get0_libctx(), collect_keymanagers,
650 km_stack);
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);
661 if (names != NULL && EVP_KEYMGMT_names_do_all(k, collect_names, names)) {
662 const char *desc = EVP_KEYMGMT_get0_description(k);
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: ");
672 print_names(bio_out, names);
673 BIO_printf(bio_out, " @ %s\n",
674 OSSL_PROVIDER_get0_name(EVP_KEYMGMT_get0_provider(k)));
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 }
684 }
685 sk_OPENSSL_CSTRING_free(names);
686 }
687 sk_EVP_KEYMGMT_pop_free(km_stack, EVP_KEYMGMT_free);
688 }
689
DEFINE_STACK_OF(EVP_SIGNATURE)690 DEFINE_STACK_OF(EVP_SIGNATURE)
691 static int signature_cmp(const EVP_SIGNATURE * const *a,
692 const EVP_SIGNATURE * const *b)
693 {
694 return strcmp(OSSL_PROVIDER_get0_name(EVP_SIGNATURE_get0_provider(*a)),
695 OSSL_PROVIDER_get0_name(EVP_SIGNATURE_get0_provider(*b)));
696 }
697
collect_signatures(EVP_SIGNATURE * sig,void * stack)698 static void collect_signatures(EVP_SIGNATURE *sig, void *stack)
699 {
700 STACK_OF(EVP_SIGNATURE) *sig_stack = stack;
701
702 if (is_signature_fetchable(sig)
703 && sk_EVP_SIGNATURE_push(sig_stack, sig) > 0)
704 EVP_SIGNATURE_up_ref(sig);
705 }
706
list_signatures(void)707 static void list_signatures(void)
708 {
709 int i, count = 0;
710 STACK_OF(EVP_SIGNATURE) *sig_stack = sk_EVP_SIGNATURE_new(signature_cmp);
711
712 EVP_SIGNATURE_do_all_provided(app_get0_libctx(), collect_signatures,
713 sig_stack);
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);
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",
730 OSSL_PROVIDER_get0_name(EVP_SIGNATURE_get0_provider(k)));
731
732 if (verbose) {
733 const char *desc = EVP_SIGNATURE_get0_description(k);
734
735 if (desc != NULL)
736 BIO_printf(bio_out, " description: %s\n", desc);
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 }
742 }
743 sk_OPENSSL_CSTRING_free(names);
744 }
745 sk_EVP_SIGNATURE_pop_free(sig_stack, EVP_SIGNATURE_free);
746 if (count == 0)
747 BIO_printf(bio_out, " -\n");
748 }
749
DEFINE_STACK_OF(EVP_KEM)750 DEFINE_STACK_OF(EVP_KEM)
751 static int kem_cmp(const EVP_KEM * const *a,
752 const EVP_KEM * const *b)
753 {
754 return strcmp(OSSL_PROVIDER_get0_name(EVP_KEM_get0_provider(*a)),
755 OSSL_PROVIDER_get0_name(EVP_KEM_get0_provider(*b)));
756 }
757
collect_kem(EVP_KEM * kem,void * stack)758 static void collect_kem(EVP_KEM *kem, void *stack)
759 {
760 STACK_OF(EVP_KEM) *kem_stack = stack;
761
762 if (is_kem_fetchable(kem)
763 && sk_EVP_KEM_push(kem_stack, kem) > 0)
764 EVP_KEM_up_ref(kem);
765 }
766
list_kems(void)767 static void list_kems(void)
768 {
769 int i, count = 0;
770 STACK_OF(EVP_KEM) *kem_stack = sk_EVP_KEM_new(kem_cmp);
771
772 EVP_KEM_do_all_provided(app_get0_libctx(), collect_kem, kem_stack);
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);
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
788 BIO_printf(bio_out, " @ %s\n",
789 OSSL_PROVIDER_get0_name(EVP_KEM_get0_provider(k)));
790
791 if (verbose) {
792 const char *desc = EVP_KEM_get0_description(k);
793
794 if (desc != NULL)
795 BIO_printf(bio_out, " description: %s\n", desc);
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 }
801 }
802 sk_OPENSSL_CSTRING_free(names);
803 }
804 sk_EVP_KEM_pop_free(kem_stack, EVP_KEM_free);
805 if (count == 0)
806 BIO_printf(bio_out, " -\n");
807 }
808
DEFINE_STACK_OF(EVP_ASYM_CIPHER)809 DEFINE_STACK_OF(EVP_ASYM_CIPHER)
810 static int asymcipher_cmp(const EVP_ASYM_CIPHER * const *a,
811 const EVP_ASYM_CIPHER * const *b)
812 {
813 return strcmp(OSSL_PROVIDER_get0_name(EVP_ASYM_CIPHER_get0_provider(*a)),
814 OSSL_PROVIDER_get0_name(EVP_ASYM_CIPHER_get0_provider(*b)));
815 }
816
collect_asymciph(EVP_ASYM_CIPHER * asym_cipher,void * stack)817 static void collect_asymciph(EVP_ASYM_CIPHER *asym_cipher, void *stack)
818 {
819 STACK_OF(EVP_ASYM_CIPHER) *asym_cipher_stack = stack;
820
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);
824 }
825
list_asymciphers(void)826 static 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
832 EVP_ASYM_CIPHER_do_all_provided(app_get0_libctx(), collect_asymciph,
833 asymciph_stack);
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);
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",
851 OSSL_PROVIDER_get0_name(EVP_ASYM_CIPHER_get0_provider(k)));
852
853 if (verbose) {
854 const char *desc = EVP_ASYM_CIPHER_get0_description(k);
855
856 if (desc != NULL)
857 BIO_printf(bio_out, " description: %s\n", desc);
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 }
863 }
864 sk_OPENSSL_CSTRING_free(names);
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
DEFINE_STACK_OF(EVP_KEYEXCH)871 DEFINE_STACK_OF(EVP_KEYEXCH)
872 static int kex_cmp(const EVP_KEYEXCH * const *a,
873 const EVP_KEYEXCH * const *b)
874 {
875 return strcmp(OSSL_PROVIDER_get0_name(EVP_KEYEXCH_get0_provider(*a)),
876 OSSL_PROVIDER_get0_name(EVP_KEYEXCH_get0_provider(*b)));
877 }
878
collect_kex(EVP_KEYEXCH * kex,void * stack)879 static void collect_kex(EVP_KEYEXCH *kex, void *stack)
880 {
881 STACK_OF(EVP_KEYEXCH) *kex_stack = stack;
882
883 if (is_keyexch_fetchable(kex)
884 && sk_EVP_KEYEXCH_push(kex_stack, kex) > 0)
885 EVP_KEYEXCH_up_ref(kex);
886 }
887
list_keyexchanges(void)888 static void list_keyexchanges(void)
889 {
890 int i, count = 0;
891 STACK_OF(EVP_KEYEXCH) *kex_stack = sk_EVP_KEYEXCH_new(kex_cmp);
892
893 EVP_KEYEXCH_do_all_provided(app_get0_libctx(), collect_kex, kex_stack);
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);
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",
910 OSSL_PROVIDER_get0_name(EVP_KEYEXCH_get0_provider(k)));
911
912 if (verbose) {
913 const char *desc = EVP_KEYEXCH_get0_description(k);
914
915 if (desc != NULL)
916 BIO_printf(bio_out, " description: %s\n", desc);
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 }
922 }
923 sk_OPENSSL_CSTRING_free(names);
924 }
925 sk_EVP_KEYEXCH_pop_free(kex_stack, EVP_KEYEXCH_free);
926 if (count == 0)
927 BIO_printf(bio_out, " -\n");
928 }
929
list_objects(void)930 static 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
list_options_for_command(const char * command)980 static 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",
990 command);
991 return;
992 }
993
994 if ((o = fp->help) == NULL)
995 return;
996
997 for ( ; o->name != NULL; o++) {
998 char c = o->valtype;
999
1000 if (o->name == OPT_PARAM_STR)
1001 break;
1002
1003 if (o->name == OPT_HELP_STR
1004 || o->name == OPT_MORE_STR
1005 || o->name == OPT_SECTION_STR
1006 || o->name[0] == '\0')
1007 continue;
1008 BIO_printf(bio_out, "%s %c\n", o->name, c == '\0' ? '-' : c);
1009 }
1010 /* Always output the -- marker since it is sometimes documented. */
1011 BIO_printf(bio_out, "- -\n");
1012 }
1013
is_md_available(const char * name)1014 static int is_md_available(const char *name)
1015 {
1016 EVP_MD *md;
1017 const char *propq = app_get0_propq();
1018
1019 /* Look through providers' digests */
1020 ERR_set_mark();
1021 md = EVP_MD_fetch(app_get0_libctx(), name, propq);
1022 ERR_pop_to_mark();
1023 if (md != NULL) {
1024 EVP_MD_free(md);
1025 return 1;
1026 }
1027
1028 return propq != NULL || get_digest_from_engine(name) == NULL ? 0 : 1;
1029 }
1030
is_cipher_available(const char * name)1031 static int is_cipher_available(const char *name)
1032 {
1033 EVP_CIPHER *cipher;
1034 const char *propq = app_get0_propq();
1035
1036 /* Look through providers' ciphers */
1037 ERR_set_mark();
1038 cipher = EVP_CIPHER_fetch(app_get0_libctx(), name, propq);
1039 ERR_pop_to_mark();
1040 if (cipher != NULL) {
1041 EVP_CIPHER_free(cipher);
1042 return 1;
1043 }
1044
1045 return propq != NULL || get_cipher_from_engine(name) == NULL ? 0 : 1;
1046 }
1047
list_type(FUNC_TYPE ft,int one)1048 static 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;
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 }
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
list_pkey(void)1086 static void list_pkey(void)
1087 {
1088 #ifndef OPENSSL_NO_DEPRECATED_3_0
1089 int i;
1090
1091 if (select_name == NULL && include_legacy()) {
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 }
1114 }
1115 }
1116 #endif
1117 BIO_printf(bio_out, "Provided:\n");
1118 BIO_printf(bio_out, " Key Managers:\n");
1119 list_keymanagers();
1120 }
1121
list_pkey_meth(void)1122 static void list_pkey_meth(void)
1123 {
1124 #ifndef OPENSSL_NO_DEPRECATED_3_0
1125 size_t i;
1126 size_t meth_count = EVP_PKEY_meth_get_count();
1127
1128 if (select_name == NULL && include_legacy()) {
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;
1133
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 }
1139 }
1140 #endif
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 }
1151
DEFINE_STACK_OF(OSSL_STORE_LOADER)1152 DEFINE_STACK_OF(OSSL_STORE_LOADER)
1153 static int store_cmp(const OSSL_STORE_LOADER * const *a,
1154 const OSSL_STORE_LOADER * const *b)
1155 {
1156 return strcmp(OSSL_PROVIDER_get0_name(OSSL_STORE_LOADER_get0_provider(*a)),
1157 OSSL_PROVIDER_get0_name(OSSL_STORE_LOADER_get0_provider(*b)));
1158 }
1159
collect_store_loaders(OSSL_STORE_LOADER * store,void * stack)1160 static 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
list_store_loaders(void)1168 static 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");
1178 OSSL_STORE_LOADER_do_all_provided(app_get0_libctx(), collect_store_loaders,
1179 stores);
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",
1195 OSSL_PROVIDER_get0_name(OSSL_STORE_LOADER_get0_provider(m)));
1196 }
1197 sk_OPENSSL_CSTRING_free(names);
1198 }
1199 sk_OSSL_STORE_LOADER_pop_free(stores, OSSL_STORE_LOADER_free);
1200 }
1201
DEFINE_STACK_OF(OSSL_PROVIDER)1202 DEFINE_STACK_OF(OSSL_PROVIDER)
1203 static int provider_cmp(const OSSL_PROVIDER * const *a,
1204 const OSSL_PROVIDER * const *b)
1205 {
1206 return strcmp(OSSL_PROVIDER_get0_name(*a), OSSL_PROVIDER_get0_name(*b));
1207 }
1208
collect_providers(OSSL_PROVIDER * provider,void * stack)1209 static int collect_providers(OSSL_PROVIDER *provider, void *stack)
1210 {
1211 STACK_OF(OSSL_PROVIDER) *provider_stack = stack;
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;
1217 }
1218
list_provider_info(void)1219 static 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 }
1231
1232 if (OSSL_PROVIDER_do_all(NULL, &collect_providers, providers) != 1) {
1233 sk_OSSL_PROVIDER_free(providers);
1234 BIO_printf(bio_err, "ERROR: Memory allocation\n");
1235 return;
1236 }
1237
1238 BIO_printf(bio_out, "Providers:\n");
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);
1242 const char *provname = OSSL_PROVIDER_get0_name(prov);
1243
1244 BIO_printf(bio_out, " %s\n", provname);
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)) {
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 }
1274 }
1275 }
1276 sk_OSSL_PROVIDER_free(providers);
1277 }
1278
1279 #ifndef OPENSSL_NO_DEPRECATED_3_0
list_engines(void)1280 static void list_engines(void)
1281 {
1282 # ifndef OPENSSL_NO_ENGINE
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 }
1291 # else
1292 BIO_puts(bio_out, "Engine support is disabled.\n");
1293 # endif
1294 }
1295 #endif
1296
list_disabled(void)1297 static void list_disabled(void)
1298 {
1299 BIO_puts(bio_out, "Disabled algorithms:\n");
1300 #ifdef OPENSSL_NO_ARIA
1301 BIO_puts(bio_out, "ARIA\n");
1302 #endif
1303 #ifdef OPENSSL_NO_BF
1304 BIO_puts(bio_out, "BF\n");
1305 #endif
1306 #ifdef OPENSSL_NO_BLAKE2
1307 BIO_puts(bio_out, "BLAKE2\n");
1308 #endif
1309 #ifdef OPENSSL_NO_CAMELLIA
1310 BIO_puts(bio_out, "CAMELLIA\n");
1311 #endif
1312 #ifdef OPENSSL_NO_CAST
1313 BIO_puts(bio_out, "CAST\n");
1314 #endif
1315 #ifdef OPENSSL_NO_CMAC
1316 BIO_puts(bio_out, "CMAC\n");
1317 #endif
1318 #ifdef OPENSSL_NO_CMS
1319 BIO_puts(bio_out, "CMS\n");
1320 #endif
1321 #ifdef OPENSSL_NO_COMP
1322 BIO_puts(bio_out, "COMP\n");
1323 #endif
1324 #ifdef OPENSSL_NO_DES
1325 BIO_puts(bio_out, "DES\n");
1326 #endif
1327 #ifdef OPENSSL_NO_DGRAM
1328 BIO_puts(bio_out, "DGRAM\n");
1329 #endif
1330 #ifdef OPENSSL_NO_DH
1331 BIO_puts(bio_out, "DH\n");
1332 #endif
1333 #ifdef OPENSSL_NO_DSA
1334 BIO_puts(bio_out, "DSA\n");
1335 #endif
1336 #if defined(OPENSSL_NO_DTLS)
1337 BIO_puts(bio_out, "DTLS\n");
1338 #endif
1339 #if defined(OPENSSL_NO_DTLS1)
1340 BIO_puts(bio_out, "DTLS1\n");
1341 #endif
1342 #if defined(OPENSSL_NO_DTLS1_2)
1343 BIO_puts(bio_out, "DTLS1_2\n");
1344 #endif
1345 #ifdef OPENSSL_NO_EC
1346 BIO_puts(bio_out, "EC\n");
1347 #endif
1348 #ifdef OPENSSL_NO_EC2M
1349 BIO_puts(bio_out, "EC2M\n");
1350 #endif
1351 #if defined(OPENSSL_NO_ENGINE) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1352 BIO_puts(bio_out, "ENGINE\n");
1353 #endif
1354 #ifdef OPENSSL_NO_GOST
1355 BIO_puts(bio_out, "GOST\n");
1356 #endif
1357 #ifdef OPENSSL_NO_IDEA
1358 BIO_puts(bio_out, "IDEA\n");
1359 #endif
1360 #ifdef OPENSSL_NO_MD2
1361 BIO_puts(bio_out, "MD2\n");
1362 #endif
1363 #ifdef OPENSSL_NO_MD4
1364 BIO_puts(bio_out, "MD4\n");
1365 #endif
1366 #ifdef OPENSSL_NO_MD5
1367 BIO_puts(bio_out, "MD5\n");
1368 #endif
1369 #ifdef OPENSSL_NO_MDC2
1370 BIO_puts(bio_out, "MDC2\n");
1371 #endif
1372 #ifdef OPENSSL_NO_OCB
1373 BIO_puts(bio_out, "OCB\n");
1374 #endif
1375 #ifdef OPENSSL_NO_OCSP
1376 BIO_puts(bio_out, "OCSP\n");
1377 #endif
1378 #ifdef OPENSSL_NO_PSK
1379 BIO_puts(bio_out, "PSK\n");
1380 #endif
1381 #ifdef OPENSSL_NO_RC2
1382 BIO_puts(bio_out, "RC2\n");
1383 #endif
1384 #ifdef OPENSSL_NO_RC4
1385 BIO_puts(bio_out, "RC4\n");
1386 #endif
1387 #ifdef OPENSSL_NO_RC5
1388 BIO_puts(bio_out, "RC5\n");
1389 #endif
1390 #ifdef OPENSSL_NO_RMD160
1391 BIO_puts(bio_out, "RMD160\n");
1392 #endif
1393 #ifdef OPENSSL_NO_SCRYPT
1394 BIO_puts(bio_out, "SCRYPT\n");
1395 #endif
1396 #ifdef OPENSSL_NO_SCTP
1397 BIO_puts(bio_out, "SCTP\n");
1398 #endif
1399 #ifdef OPENSSL_NO_SEED
1400 BIO_puts(bio_out, "SEED\n");
1401 #endif
1402 #ifdef OPENSSL_NO_SM2
1403 BIO_puts(bio_out, "SM2\n");
1404 #endif
1405 #ifdef OPENSSL_NO_SM3
1406 BIO_puts(bio_out, "SM3\n");
1407 #endif
1408 #ifdef OPENSSL_NO_SM4
1409 BIO_puts(bio_out, "SM4\n");
1410 #endif
1411 #ifdef OPENSSL_NO_SOCK
1412 BIO_puts(bio_out, "SOCK\n");
1413 #endif
1414 #ifdef OPENSSL_NO_SRP
1415 BIO_puts(bio_out, "SRP\n");
1416 #endif
1417 #ifdef OPENSSL_NO_SRTP
1418 BIO_puts(bio_out, "SRTP\n");
1419 #endif
1420 #ifdef OPENSSL_NO_SSL3
1421 BIO_puts(bio_out, "SSL3\n");
1422 #endif
1423 #ifdef OPENSSL_NO_TLS1
1424 BIO_puts(bio_out, "TLS1\n");
1425 #endif
1426 #ifdef OPENSSL_NO_TLS1_1
1427 BIO_puts(bio_out, "TLS1_1\n");
1428 #endif
1429 #ifdef OPENSSL_NO_TLS1_2
1430 BIO_puts(bio_out, "TLS1_2\n");
1431 #endif
1432 #ifdef OPENSSL_NO_WHIRLPOOL
1433 BIO_puts(bio_out, "WHIRLPOOL\n");
1434 #endif
1435 #ifndef ZLIB
1436 BIO_puts(bio_out, "ZLIB\n");
1437 #endif
1438 }
1439
1440 /* Unified enum for help and list commands. */
1441 typedef enum HELPLIST_CHOICE {
1442 OPT_COMMON,
1443 OPT_ONE, OPT_VERBOSE,
1444 OPT_COMMANDS, OPT_DIGEST_COMMANDS, OPT_MAC_ALGORITHMS, OPT_OPTIONS,
1445 OPT_DIGEST_ALGORITHMS, OPT_CIPHER_COMMANDS, OPT_CIPHER_ALGORITHMS,
1446 OPT_PK_ALGORITHMS, OPT_PK_METHOD, OPT_DISABLED,
1447 OPT_KDF_ALGORITHMS, OPT_RANDOM_INSTANCES, OPT_RANDOM_GENERATORS,
1448 OPT_ENCODERS, OPT_DECODERS, OPT_KEYMANAGERS, OPT_KEYEXCHANGE_ALGORITHMS,
1449 OPT_KEM_ALGORITHMS, OPT_SIGNATURE_ALGORITHMS, OPT_ASYM_CIPHER_ALGORITHMS,
1450 OPT_STORE_LOADERS, OPT_PROVIDER_INFO,
1451 OPT_OBJECTS, OPT_SELECT_NAME,
1452 #ifndef OPENSSL_NO_DEPRECATED_3_0
1453 OPT_ENGINES,
1454 #endif
1455 OPT_PROV_ENUM
1456 } HELPLIST_CHOICE;
1457
1458 const OPTIONS list_options[] = {
1459
1460 OPT_SECTION("General"),
1461 {"help", OPT_HELP, '-', "Display this summary"},
1462
1463 OPT_SECTION("Output"),
1464 {"1", OPT_ONE, '-', "List in one column"},
1465 {"verbose", OPT_VERBOSE, '-', "Verbose listing"},
1466 {"select", OPT_SELECT_NAME, 's', "Select a single algorithm"},
1467 {"commands", OPT_COMMANDS, '-', "List of standard commands"},
1468 {"standard-commands", OPT_COMMANDS, '-', "List of standard commands"},
1469 #ifndef OPENSSL_NO_DEPRECATED_3_0
1470 {"digest-commands", OPT_DIGEST_COMMANDS, '-',
1471 "List of message digest commands (deprecated)"},
1472 #endif
1473 {"digest-algorithms", OPT_DIGEST_ALGORITHMS, '-',
1474 "List of message digest algorithms"},
1475 {"kdf-algorithms", OPT_KDF_ALGORITHMS, '-',
1476 "List of key derivation and pseudo random function algorithms"},
1477 {"random-instances", OPT_RANDOM_INSTANCES, '-',
1478 "List the primary, public and private random number generator details"},
1479 {"random-generators", OPT_RANDOM_GENERATORS, '-',
1480 "List of random number generators"},
1481 {"mac-algorithms", OPT_MAC_ALGORITHMS, '-',
1482 "List of message authentication code algorithms"},
1483 #ifndef OPENSSL_NO_DEPRECATED_3_0
1484 {"cipher-commands", OPT_CIPHER_COMMANDS, '-',
1485 "List of cipher commands (deprecated)"},
1486 #endif
1487 {"cipher-algorithms", OPT_CIPHER_ALGORITHMS, '-',
1488 "List of symmetric cipher algorithms"},
1489 {"encoders", OPT_ENCODERS, '-', "List of encoding methods" },
1490 {"decoders", OPT_DECODERS, '-', "List of decoding methods" },
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" },
1498 {"asymcipher-algorithms", OPT_ASYM_CIPHER_ALGORITHMS, '-',
1499 "List of asymmetric cipher algorithms" },
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"},
1504 {"store-loaders", OPT_STORE_LOADERS, '-',
1505 "List of store loaders"},
1506 {"providers", OPT_PROVIDER_INFO, '-',
1507 "List of provider information"},
1508 #ifndef OPENSSL_NO_DEPRECATED_3_0
1509 {"engines", OPT_ENGINES, '-',
1510 "List of loaded engines"},
1511 #endif
1512 {"disabled", OPT_DISABLED, '-', "List of disabled features"},
1513 {"options", OPT_OPTIONS, 's',
1514 "List options for specified command"},
1515 {"objects", OPT_OBJECTS, '-',
1516 "List built in objects (OID<->name mappings)"},
1517
1518 OPT_PROV_OPTIONS,
1519 {NULL}
1520 };
1521
list_main(int argc,char ** argv)1522 int list_main(int argc, char **argv)
1523 {
1524 char *prog;
1525 HELPLIST_CHOICE o;
1526 int one = 0, done = 0;
1527 struct {
1528 unsigned int commands:1;
1529 unsigned int random_instances:1;
1530 unsigned int random_generators:1;
1531 unsigned int digest_commands:1;
1532 unsigned int digest_algorithms:1;
1533 unsigned int kdf_algorithms:1;
1534 unsigned int mac_algorithms:1;
1535 unsigned int cipher_commands:1;
1536 unsigned int cipher_algorithms:1;
1537 unsigned int encoder_algorithms:1;
1538 unsigned int decoder_algorithms:1;
1539 unsigned int keymanager_algorithms:1;
1540 unsigned int signature_algorithms:1;
1541 unsigned int keyexchange_algorithms:1;
1542 unsigned int kem_algorithms:1;
1543 unsigned int asym_cipher_algorithms:1;
1544 unsigned int pk_algorithms:1;
1545 unsigned int pk_method:1;
1546 unsigned int store_loaders:1;
1547 unsigned int provider_info:1;
1548 #ifndef OPENSSL_NO_DEPRECATED_3_0
1549 unsigned int engines:1;
1550 #endif
1551 unsigned int disabled:1;
1552 unsigned int objects:1;
1553 unsigned int options:1;
1554 } todo = { 0, };
1555
1556 verbose = 0; /* Clear a possible previous call */
1557
1558 prog = opt_init(argc, argv, list_options);
1559 while ((o = opt_next()) != OPT_EOF) {
1560 switch (o) {
1561 case OPT_EOF: /* Never hit, but suppresses warning */
1562 case OPT_ERR:
1563 opthelp:
1564 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1565 return 1;
1566 case OPT_HELP:
1567 opt_help(list_options);
1568 return 0;
1569 case OPT_ONE:
1570 one = 1;
1571 break;
1572 case OPT_COMMANDS:
1573 todo.commands = 1;
1574 break;
1575 case OPT_DIGEST_COMMANDS:
1576 todo.digest_commands = 1;
1577 break;
1578 case OPT_DIGEST_ALGORITHMS:
1579 todo.digest_algorithms = 1;
1580 break;
1581 case OPT_KDF_ALGORITHMS:
1582 todo.kdf_algorithms = 1;
1583 break;
1584 case OPT_RANDOM_INSTANCES:
1585 todo.random_instances = 1;
1586 break;
1587 case OPT_RANDOM_GENERATORS:
1588 todo.random_generators = 1;
1589 break;
1590 case OPT_MAC_ALGORITHMS:
1591 todo.mac_algorithms = 1;
1592 break;
1593 case OPT_CIPHER_COMMANDS:
1594 todo.cipher_commands = 1;
1595 break;
1596 case OPT_CIPHER_ALGORITHMS:
1597 todo.cipher_algorithms = 1;
1598 break;
1599 case OPT_ENCODERS:
1600 todo.encoder_algorithms = 1;
1601 break;
1602 case OPT_DECODERS:
1603 todo.decoder_algorithms = 1;
1604 break;
1605 case OPT_KEYMANAGERS:
1606 todo.keymanager_algorithms = 1;
1607 break;
1608 case OPT_SIGNATURE_ALGORITHMS:
1609 todo.signature_algorithms = 1;
1610 break;
1611 case OPT_KEYEXCHANGE_ALGORITHMS:
1612 todo.keyexchange_algorithms = 1;
1613 break;
1614 case OPT_KEM_ALGORITHMS:
1615 todo.kem_algorithms = 1;
1616 break;
1617 case OPT_ASYM_CIPHER_ALGORITHMS:
1618 todo.asym_cipher_algorithms = 1;
1619 break;
1620 case OPT_PK_ALGORITHMS:
1621 todo.pk_algorithms = 1;
1622 break;
1623 case OPT_PK_METHOD:
1624 todo.pk_method = 1;
1625 break;
1626 case OPT_STORE_LOADERS:
1627 todo.store_loaders = 1;
1628 break;
1629 case OPT_PROVIDER_INFO:
1630 todo.provider_info = 1;
1631 break;
1632 #ifndef OPENSSL_NO_DEPRECATED_3_0
1633 case OPT_ENGINES:
1634 todo.engines = 1;
1635 break;
1636 #endif
1637 case OPT_DISABLED:
1638 todo.disabled = 1;
1639 break;
1640 case OPT_OBJECTS:
1641 todo.objects = 1;
1642 break;
1643 case OPT_OPTIONS:
1644 list_options_for_command(opt_arg());
1645 break;
1646 case OPT_VERBOSE:
1647 verbose = 1;
1648 break;
1649 case OPT_SELECT_NAME:
1650 select_name = opt_arg();
1651 break;
1652 case OPT_PROV_CASES:
1653 if (!opt_provider(o))
1654 return 1;
1655 break;
1656 }
1657 done = 1;
1658 }
1659
1660 /* No extra arguments. */
1661 if (opt_num_rest() != 0)
1662 goto opthelp;
1663
1664 if (todo.commands)
1665 list_type(FT_general, one);
1666 if (todo.random_instances)
1667 list_random_instances();
1668 if (todo.random_generators)
1669 list_random_generators();
1670 if (todo.digest_commands)
1671 list_type(FT_md, one);
1672 if (todo.digest_algorithms)
1673 list_digests();
1674 if (todo.kdf_algorithms)
1675 list_kdfs();
1676 if (todo.mac_algorithms)
1677 list_macs();
1678 if (todo.cipher_commands)
1679 list_type(FT_cipher, one);
1680 if (todo.cipher_algorithms)
1681 list_ciphers();
1682 if (todo.encoder_algorithms)
1683 list_encoders();
1684 if (todo.decoder_algorithms)
1685 list_decoders();
1686 if (todo.keymanager_algorithms)
1687 list_keymanagers();
1688 if (todo.signature_algorithms)
1689 list_signatures();
1690 if (todo.asym_cipher_algorithms)
1691 list_asymciphers();
1692 if (todo.keyexchange_algorithms)
1693 list_keyexchanges();
1694 if (todo.kem_algorithms)
1695 list_kems();
1696 if (todo.pk_algorithms)
1697 list_pkey();
1698 if (todo.pk_method)
1699 list_pkey_meth();
1700 if (todo.store_loaders)
1701 list_store_loaders();
1702 if (todo.provider_info)
1703 list_provider_info();
1704 #ifndef OPENSSL_NO_DEPRECATED_3_0
1705 if (todo.engines)
1706 list_engines();
1707 #endif
1708 if (todo.disabled)
1709 list_disabled();
1710 if (todo.objects)
1711 list_objects();
1712
1713 if (!done)
1714 goto opthelp;
1715
1716 return 0;
1717 }
1718