2 * Copyright 2016-2020 The OpenSSL Project Authors. All Rights Reserved.
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
14 /* We need to use some STORE deprecated APIs */
15 #define OPENSSL_SUPPRESS_DEPRECATED
19 #include <openssl/crypto.h>
20 #include <openssl/err.h>
21 #include <openssl/trace.h>
22 #include <openssl/core_names.h>
23 #include <openssl/provider.h>
24 #include <openssl/param_build.h>
25 #include <openssl/store.h>
26 #include "internal/thread_once.h"
27 #include "internal/cryptlib.h"
28 #include "internal/provider.h"
29 #include "crypto/store.h"
30 #include "store_local.h"
32 static int ossl_store_close_it(OSSL_STORE_CTX *ctx);
35 OSSL_STORE_open_with_libctx(const char *uri,
36 OPENSSL_CTX *libctx, const char *propq,
37 const UI_METHOD *ui_method, void *ui_data,
38 OSSL_STORE_post_process_info_fn post_process,
39 void *post_process_data)
41 const OSSL_STORE_LOADER *loader = NULL;
42 OSSL_STORE_LOADER *fetched_loader = NULL;
43 OSSL_STORE_LOADER_CTX *loader_ctx = NULL;
44 OSSL_STORE_CTX *ctx = NULL;
45 char *propq_copy = NULL;
46 char scheme_copy[256], *p, *schemes[2];
51 * Put the file scheme first. If the uri does represent an existing file,
52 * possible device name and all, then it should be loaded. Only a failed
53 * attempt at loading a local file should have us try something else.
55 schemes[schemes_n++] = "file";
58 * Now, check if we have something that looks like a scheme, and add it
59 * as a second scheme. However, also check if there's an authority start
60 * (://), because that will invalidate the previous file scheme. Also,
61 * check that this isn't actually the file scheme, as there's no point
62 * going through that one twice!
64 OPENSSL_strlcpy(scheme_copy, uri, sizeof(scheme_copy));
65 if ((p = strchr(scheme_copy, ':')) != NULL) {
67 if (strcasecmp(scheme_copy, "file") != 0) {
68 if (strncmp(p, "//", 2) == 0)
69 schemes_n--; /* Invalidate the file scheme */
70 schemes[schemes_n++] = scheme_copy;
77 * Try each scheme until we find one that could open the URI.
79 * For each scheme, we look for the engine implementation first, and
80 * failing that, we then try to fetch a provided implementation.
81 * This is consistent with how we handle legacy / engine implementations
84 for (i = 0; loader_ctx == NULL && i < schemes_n; i++) {
85 OSSL_TRACE1(STORE, "Looking up scheme %s\n", schemes[i]);
86 #ifndef OPENSSL_NO_DEPRECATED_3_0
87 if ((loader = ossl_store_get0_loader_int(schemes[i])) != NULL) {
88 if (loader->open_with_libctx != NULL)
89 loader_ctx = loader->open_with_libctx(loader, uri, libctx, propq,
92 loader_ctx = loader->open(loader, uri, ui_method, ui_data);
97 OSSL_STORE_LOADER_fetch(schemes[i], libctx, propq)) != NULL) {
98 const OSSL_PROVIDER *provider =
99 OSSL_STORE_LOADER_provider(fetched_loader);
100 void *provctx = OSSL_PROVIDER_get0_provider_ctx(provider);
102 loader_ctx = fetched_loader->p_open(provctx, uri);
103 if (loader_ctx == NULL) {
104 OSSL_STORE_LOADER_free(fetched_loader);
105 fetched_loader = NULL;
106 } else if (propq != NULL) {
107 OSSL_PARAM params[] = {
108 OSSL_PARAM_utf8_string(OSSL_STORE_PARAM_PROPERTIES,
113 params[0].data = (void *)propq;
114 if (!fetched_loader->p_set_ctx_params(loader_ctx, params)) {
115 (void)fetched_loader->p_close(loader_ctx);
116 OSSL_STORE_LOADER_free(fetched_loader);
117 fetched_loader = NULL;
120 loader = fetched_loader;
125 OSSL_TRACE1(STORE, "Found loader for scheme %s\n", schemes[i]);
127 if (loader_ctx == NULL)
130 OSSL_TRACE2(STORE, "Opened %s => %p\n", uri, (void *)loader_ctx);
132 if ((propq != NULL && (propq_copy = OPENSSL_strdup(propq)) == NULL)
133 || (ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL) {
134 ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
138 if ((ui_method != NULL
139 && !ossl_pw_set_ui_method(&ctx->pwdata, ui_method, ui_data))
140 || !ossl_pw_enable_passphrase_caching(&ctx->pwdata)) {
141 ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_CRYPTO_LIB);
144 ctx->properties = propq_copy;
145 ctx->fetched_loader = fetched_loader;
146 ctx->loader = loader;
147 ctx->loader_ctx = loader_ctx;
148 ctx->post_process = post_process;
149 ctx->post_process_data = post_process_data;
152 * If the attempt to open with the 'file' scheme loader failed and the
153 * other scheme loader succeeded, the failure to open with the 'file'
154 * scheme loader leaves an error on the error stack. Let's remove it.
161 ERR_clear_last_mark();
162 if (loader_ctx != NULL) {
164 * Temporary structure so OSSL_STORE_close() can work even when
165 * |ctx| couldn't be allocated properly
167 OSSL_STORE_CTX tmpctx = { NULL, };
169 tmpctx.fetched_loader = fetched_loader;
170 tmpctx.loader = loader;
171 tmpctx.loader_ctx = loader_ctx;
174 * We ignore a returned error because we will return NULL anyway in
175 * this case, so if something goes wrong when closing, that'll simply
176 * just add another entry on the error stack.
178 (void)ossl_store_close_it(&tmpctx);
180 OSSL_STORE_LOADER_free(fetched_loader);
181 OPENSSL_free(propq_copy);
185 OSSL_STORE_CTX *OSSL_STORE_open(const char *uri,
186 const UI_METHOD *ui_method, void *ui_data,
187 OSSL_STORE_post_process_info_fn post_process,
188 void *post_process_data)
190 return OSSL_STORE_open_with_libctx(uri, NULL, NULL, ui_method, ui_data,
191 post_process, post_process_data);
194 #ifndef OPENSSL_NO_DEPRECATED_3_0
195 int OSSL_STORE_ctrl(OSSL_STORE_CTX *ctx, int cmd, ...)
201 ret = OSSL_STORE_vctrl(ctx, cmd, args);
207 int OSSL_STORE_vctrl(OSSL_STORE_CTX *ctx, int cmd, va_list args)
209 if (ctx->fetched_loader != NULL) {
210 if (ctx->fetched_loader->p_set_ctx_params != NULL) {
211 OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
214 case OSSL_STORE_C_USE_SECMEM:
216 int on = *(va_arg(args, int *));
218 params[0] = OSSL_PARAM_construct_int("use_secmem", &on);
225 return ctx->fetched_loader->p_set_ctx_params(ctx->loader_ctx,
228 } else if (ctx->loader->ctrl != NULL) {
229 return ctx->loader->ctrl(ctx->loader_ctx, cmd, args);
233 * If the fetched loader doesn't have a set_ctx_params or a ctrl, it's as
234 * if there was one that ignored our params, which usually returns 1.
240 int OSSL_STORE_expect(OSSL_STORE_CTX *ctx, int expected_type)
245 ERR_raise(ERR_LIB_OSSL_STORE, OSSL_STORE_R_LOADING_STARTED);
249 ctx->expected_type = expected_type;
250 if (ctx->fetched_loader != NULL
251 && ctx->fetched_loader->p_set_ctx_params != NULL) {
252 OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
255 OSSL_PARAM_construct_int(OSSL_STORE_PARAM_EXPECT, &expected_type);
256 ret = ctx->fetched_loader->p_set_ctx_params(ctx->loader_ctx, params);
258 #ifndef OPENSSL_NO_DEPRECATED_3_0
259 if (ctx->fetched_loader == NULL
260 && ctx->loader->expect != NULL) {
261 ret = ctx->loader->expect(ctx->loader_ctx, expected_type);
267 int OSSL_STORE_find(OSSL_STORE_CTX *ctx, const OSSL_STORE_SEARCH *search)
272 ERR_raise(ERR_LIB_OSSL_STORE, OSSL_STORE_R_LOADING_STARTED);
276 if (ctx->fetched_loader != NULL) {
279 /* OSSL_STORE_SEARCH_BY_NAME, OSSL_STORE_SEARCH_BY_ISSUER_SERIAL*/
280 void *name_der = NULL;
282 /* OSSL_STORE_SEARCH_BY_ISSUER_SERIAL */
283 BIGNUM *number = NULL;
285 if (ctx->fetched_loader->p_set_ctx_params == NULL) {
286 ERR_raise(ERR_LIB_OSSL_STORE, OSSL_STORE_R_UNSUPPORTED_OPERATION);
290 if ((bld = OSSL_PARAM_BLD_new()) == NULL) {
291 ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
295 ret = 0; /* Assume the worst */
297 switch (search->search_type) {
298 case OSSL_STORE_SEARCH_BY_NAME:
299 if ((name_der_sz = i2d_X509_NAME(search->name,
300 (unsigned char **)&name_der)) > 0
301 && OSSL_PARAM_BLD_push_octet_string(bld,
302 OSSL_STORE_PARAM_SUBJECT,
303 name_der, name_der_sz))
306 case OSSL_STORE_SEARCH_BY_ISSUER_SERIAL:
307 if ((name_der_sz = i2d_X509_NAME(search->name,
308 (unsigned char **)&name_der)) > 0
309 && (number = ASN1_INTEGER_to_BN(search->serial, NULL)) != NULL
310 && OSSL_PARAM_BLD_push_octet_string(bld,
311 OSSL_STORE_PARAM_ISSUER,
312 name_der, name_der_sz)
313 && OSSL_PARAM_BLD_push_BN(bld, OSSL_STORE_PARAM_SERIAL,
317 case OSSL_STORE_SEARCH_BY_KEY_FINGERPRINT:
318 if (OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_STORE_PARAM_DIGEST,
319 EVP_MD_name(search->digest), 0)
320 && OSSL_PARAM_BLD_push_octet_string(bld,
321 OSSL_STORE_PARAM_FINGERPRINT,
323 search->stringlength))
326 case OSSL_STORE_SEARCH_BY_ALIAS:
327 if (OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_STORE_PARAM_ALIAS,
328 (char *)search->string,
329 search->stringlength))
334 params = OSSL_PARAM_BLD_to_param(bld);
335 ret = ctx->fetched_loader->p_set_ctx_params(ctx->loader_ctx,
337 OSSL_PARAM_BLD_free_params(params);
339 OSSL_PARAM_BLD_free(bld);
340 OPENSSL_free(name_der);
343 #ifndef OPENSSL_NO_DEPRECATED_3_0
344 /* legacy loader section */
345 if (ctx->loader->find == NULL) {
346 ERR_raise(ERR_LIB_OSSL_STORE, OSSL_STORE_R_UNSUPPORTED_OPERATION);
349 ret = ctx->loader->find(ctx->loader_ctx, search);
356 OSSL_STORE_INFO *OSSL_STORE_load(OSSL_STORE_CTX *ctx)
358 OSSL_STORE_INFO *v = NULL;
362 if (OSSL_STORE_eof(ctx))
365 if (ctx->loader != NULL)
366 OSSL_TRACE(STORE, "Loading next object\n");
368 if (ctx->cached_info != NULL
369 && sk_OSSL_STORE_INFO_num(ctx->cached_info) == 0) {
370 sk_OSSL_STORE_INFO_free(ctx->cached_info);
371 ctx->cached_info = NULL;
374 if (ctx->cached_info != NULL) {
375 v = sk_OSSL_STORE_INFO_shift(ctx->cached_info);
377 if (ctx->fetched_loader != NULL) {
378 struct ossl_load_result_data_st load_data;
383 if (!ctx->fetched_loader->p_load(ctx->loader_ctx,
384 ossl_store_handle_load_result,
386 ossl_pw_passphrase_callback_dec,
388 if (!OSSL_STORE_eof(ctx))
394 #ifndef OPENSSL_NO_DEPRECATED_3_0
395 if (ctx->fetched_loader == NULL)
396 v = ctx->loader->load(ctx->loader_ctx,
397 ctx->pwdata._.ui_method.ui_method,
398 ctx->pwdata._.ui_method.ui_method_data);
402 if (ctx->post_process != NULL && v != NULL) {
403 v = ctx->post_process(v, ctx->post_process_data);
406 * By returning NULL, the callback decides that this object should
413 if (v != NULL && ctx->expected_type != 0) {
414 int returned_type = OSSL_STORE_INFO_get_type(v);
416 if (returned_type != OSSL_STORE_INFO_NAME && returned_type != 0) {
417 if (ctx->expected_type != returned_type) {
418 OSSL_STORE_INFO_free(v);
424 ossl_pw_clear_passphrase_cache(&ctx->pwdata);
426 OSSL_TRACE1(STORE, "Got a %s\n",
427 OSSL_STORE_INFO_type_string(OSSL_STORE_INFO_get_type(v)));
432 int OSSL_STORE_error(OSSL_STORE_CTX *ctx)
436 if (ctx->fetched_loader != NULL)
437 ret = ctx->error_flag;
438 #ifndef OPENSSL_NO_DEPRECATED_3_0
439 if (ctx->fetched_loader == NULL)
440 ret = ctx->loader->error(ctx->loader_ctx);
445 int OSSL_STORE_eof(OSSL_STORE_CTX *ctx)
449 if (ctx->fetched_loader != NULL)
450 ret = ctx->loader->p_eof(ctx->loader_ctx);
451 #ifndef OPENSSL_NO_DEPRECATED_3_0
452 if (ctx->fetched_loader == NULL)
453 ret = ctx->loader->eof(ctx->loader_ctx);
458 static int ossl_store_close_it(OSSL_STORE_CTX *ctx)
464 OSSL_TRACE1(STORE, "Closing %p\n", (void *)ctx->loader_ctx);
466 if (ctx->fetched_loader != NULL)
467 ret = ctx->loader->p_close(ctx->loader_ctx);
468 #ifndef OPENSSL_NO_DEPRECATED_3_0
469 if (ctx->fetched_loader == NULL)
470 ret = ctx->loader->close(ctx->loader_ctx);
473 sk_OSSL_STORE_INFO_pop_free(ctx->cached_info, OSSL_STORE_INFO_free);
474 OSSL_STORE_LOADER_free(ctx->fetched_loader);
475 OPENSSL_free(ctx->properties);
476 ossl_pw_clear_passphrase_data(&ctx->pwdata);
480 int OSSL_STORE_close(OSSL_STORE_CTX *ctx)
482 int ret = ossl_store_close_it(ctx);
489 * Functions to generate OSSL_STORE_INFOs, one function for each type we
490 * support having in them as well as a generic constructor.
492 * In all cases, ownership of the object is transferred to the OSSL_STORE_INFO
493 * and will therefore be freed when the OSSL_STORE_INFO is freed.
495 OSSL_STORE_INFO *OSSL_STORE_INFO_new(int type, void *data)
497 OSSL_STORE_INFO *info = OPENSSL_zalloc(sizeof(*info));
507 OSSL_STORE_INFO *OSSL_STORE_INFO_new_NAME(char *name)
509 OSSL_STORE_INFO *info = OSSL_STORE_INFO_new(OSSL_STORE_INFO_NAME, NULL);
512 ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
516 info->_.name.name = name;
517 info->_.name.desc = NULL;
522 int OSSL_STORE_INFO_set0_NAME_description(OSSL_STORE_INFO *info, char *desc)
524 if (info->type != OSSL_STORE_INFO_NAME) {
525 ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_PASSED_INVALID_ARGUMENT);
529 info->_.name.desc = desc;
533 OSSL_STORE_INFO *OSSL_STORE_INFO_new_PARAMS(EVP_PKEY *params)
535 OSSL_STORE_INFO *info = OSSL_STORE_INFO_new(OSSL_STORE_INFO_PARAMS, params);
538 ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
542 OSSL_STORE_INFO *OSSL_STORE_INFO_new_PUBKEY(EVP_PKEY *pkey)
544 OSSL_STORE_INFO *info = OSSL_STORE_INFO_new(OSSL_STORE_INFO_PUBKEY, pkey);
547 ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
551 OSSL_STORE_INFO *OSSL_STORE_INFO_new_PKEY(EVP_PKEY *pkey)
553 OSSL_STORE_INFO *info = OSSL_STORE_INFO_new(OSSL_STORE_INFO_PKEY, pkey);
556 ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
560 OSSL_STORE_INFO *OSSL_STORE_INFO_new_CERT(X509 *x509)
562 OSSL_STORE_INFO *info = OSSL_STORE_INFO_new(OSSL_STORE_INFO_CERT, x509);
565 ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
569 OSSL_STORE_INFO *OSSL_STORE_INFO_new_CRL(X509_CRL *crl)
571 OSSL_STORE_INFO *info = OSSL_STORE_INFO_new(OSSL_STORE_INFO_CRL, crl);
574 ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
579 * Functions to try to extract data from a OSSL_STORE_INFO.
581 int OSSL_STORE_INFO_get_type(const OSSL_STORE_INFO *info)
586 void *OSSL_STORE_INFO_get0_data(int type, const OSSL_STORE_INFO *info)
588 if (info->type == type)
593 const char *OSSL_STORE_INFO_get0_NAME(const OSSL_STORE_INFO *info)
595 if (info->type == OSSL_STORE_INFO_NAME)
596 return info->_.name.name;
600 char *OSSL_STORE_INFO_get1_NAME(const OSSL_STORE_INFO *info)
602 if (info->type == OSSL_STORE_INFO_NAME) {
603 char *ret = OPENSSL_strdup(info->_.name.name);
606 ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
609 ERR_raise(ERR_LIB_OSSL_STORE, OSSL_STORE_R_NOT_A_NAME);
613 const char *OSSL_STORE_INFO_get0_NAME_description(const OSSL_STORE_INFO *info)
615 if (info->type == OSSL_STORE_INFO_NAME)
616 return info->_.name.desc;
620 char *OSSL_STORE_INFO_get1_NAME_description(const OSSL_STORE_INFO *info)
622 if (info->type == OSSL_STORE_INFO_NAME) {
623 char *ret = OPENSSL_strdup(info->_.name.desc
624 ? info->_.name.desc : "");
627 ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
630 ERR_raise(ERR_LIB_OSSL_STORE, OSSL_STORE_R_NOT_A_NAME);
634 EVP_PKEY *OSSL_STORE_INFO_get0_PARAMS(const OSSL_STORE_INFO *info)
636 if (info->type == OSSL_STORE_INFO_PARAMS)
637 return info->_.params;
641 EVP_PKEY *OSSL_STORE_INFO_get1_PARAMS(const OSSL_STORE_INFO *info)
643 if (info->type == OSSL_STORE_INFO_PARAMS) {
644 EVP_PKEY_up_ref(info->_.params);
645 return info->_.params;
647 ERR_raise(ERR_LIB_OSSL_STORE, OSSL_STORE_R_NOT_PARAMETERS);
651 EVP_PKEY *OSSL_STORE_INFO_get0_PUBKEY(const OSSL_STORE_INFO *info)
653 if (info->type == OSSL_STORE_INFO_PUBKEY)
654 return info->_.pubkey;
658 EVP_PKEY *OSSL_STORE_INFO_get1_PUBKEY(const OSSL_STORE_INFO *info)
660 if (info->type == OSSL_STORE_INFO_PUBKEY) {
661 EVP_PKEY_up_ref(info->_.pubkey);
662 return info->_.pubkey;
664 OSSL_STOREerr(0, OSSL_STORE_R_NOT_A_PUBLIC_KEY);
668 EVP_PKEY *OSSL_STORE_INFO_get0_PKEY(const OSSL_STORE_INFO *info)
670 if (info->type == OSSL_STORE_INFO_PKEY)
675 EVP_PKEY *OSSL_STORE_INFO_get1_PKEY(const OSSL_STORE_INFO *info)
677 if (info->type == OSSL_STORE_INFO_PKEY) {
678 EVP_PKEY_up_ref(info->_.pkey);
681 ERR_raise(ERR_LIB_OSSL_STORE, OSSL_STORE_R_NOT_A_PRIVATE_KEY);
685 X509 *OSSL_STORE_INFO_get0_CERT(const OSSL_STORE_INFO *info)
687 if (info->type == OSSL_STORE_INFO_CERT)
692 X509 *OSSL_STORE_INFO_get1_CERT(const OSSL_STORE_INFO *info)
694 if (info->type == OSSL_STORE_INFO_CERT) {
695 X509_up_ref(info->_.x509);
698 ERR_raise(ERR_LIB_OSSL_STORE, OSSL_STORE_R_NOT_A_CERTIFICATE);
702 X509_CRL *OSSL_STORE_INFO_get0_CRL(const OSSL_STORE_INFO *info)
704 if (info->type == OSSL_STORE_INFO_CRL)
709 X509_CRL *OSSL_STORE_INFO_get1_CRL(const OSSL_STORE_INFO *info)
711 if (info->type == OSSL_STORE_INFO_CRL) {
712 X509_CRL_up_ref(info->_.crl);
715 ERR_raise(ERR_LIB_OSSL_STORE, OSSL_STORE_R_NOT_A_CRL);
720 * Free the OSSL_STORE_INFO
722 void OSSL_STORE_INFO_free(OSSL_STORE_INFO *info)
725 switch (info->type) {
726 case OSSL_STORE_INFO_NAME:
727 OPENSSL_free(info->_.name.name);
728 OPENSSL_free(info->_.name.desc);
730 case OSSL_STORE_INFO_PARAMS:
731 EVP_PKEY_free(info->_.params);
733 case OSSL_STORE_INFO_PUBKEY:
734 EVP_PKEY_free(info->_.pubkey);
736 case OSSL_STORE_INFO_PKEY:
737 EVP_PKEY_free(info->_.pkey);
739 case OSSL_STORE_INFO_CERT:
740 X509_free(info->_.x509);
742 case OSSL_STORE_INFO_CRL:
743 X509_CRL_free(info->_.crl);
750 int OSSL_STORE_supports_search(OSSL_STORE_CTX *ctx, int search_type)
754 if (ctx->fetched_loader != NULL) {
756 ossl_provider_ctx(OSSL_STORE_LOADER_provider(ctx->fetched_loader));
757 const OSSL_PARAM *params;
758 const OSSL_PARAM *p_subject = NULL;
759 const OSSL_PARAM *p_issuer = NULL;
760 const OSSL_PARAM *p_serial = NULL;
761 const OSSL_PARAM *p_fingerprint = NULL;
762 const OSSL_PARAM *p_alias = NULL;
764 if (ctx->fetched_loader->p_settable_ctx_params == NULL)
767 params = ctx->fetched_loader->p_settable_ctx_params(provctx);
768 p_subject = OSSL_PARAM_locate_const(params, OSSL_STORE_PARAM_SUBJECT);
769 p_issuer = OSSL_PARAM_locate_const(params, OSSL_STORE_PARAM_ISSUER);
770 p_serial = OSSL_PARAM_locate_const(params, OSSL_STORE_PARAM_SERIAL);
772 OSSL_PARAM_locate_const(params, OSSL_STORE_PARAM_FINGERPRINT);
773 p_alias = OSSL_PARAM_locate_const(params, OSSL_STORE_PARAM_ALIAS);
775 switch (search_type) {
776 case OSSL_STORE_SEARCH_BY_NAME:
777 ret = (p_subject != NULL);
779 case OSSL_STORE_SEARCH_BY_ISSUER_SERIAL:
780 ret = (p_issuer != NULL && p_serial != NULL);
782 case OSSL_STORE_SEARCH_BY_KEY_FINGERPRINT:
783 ret = (p_fingerprint != NULL);
785 case OSSL_STORE_SEARCH_BY_ALIAS:
786 ret = (p_alias != NULL);
790 #ifndef OPENSSL_NO_DEPRECATED_3_0
791 if (ctx->fetched_loader == NULL) {
792 OSSL_STORE_SEARCH tmp_search;
794 if (ctx->loader->find == NULL)
796 tmp_search.search_type = search_type;
797 ret = ctx->loader->find(NULL, &tmp_search);
803 /* Search term constructors */
804 OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_name(X509_NAME *name)
806 OSSL_STORE_SEARCH *search = OPENSSL_zalloc(sizeof(*search));
808 if (search == NULL) {
809 ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
813 search->search_type = OSSL_STORE_SEARCH_BY_NAME;
818 OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_issuer_serial(X509_NAME *name,
819 const ASN1_INTEGER *serial)
821 OSSL_STORE_SEARCH *search = OPENSSL_zalloc(sizeof(*search));
823 if (search == NULL) {
824 ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
828 search->search_type = OSSL_STORE_SEARCH_BY_ISSUER_SERIAL;
830 search->serial = serial;
834 OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_key_fingerprint(const EVP_MD *digest,
838 OSSL_STORE_SEARCH *search = OPENSSL_zalloc(sizeof(*search));
840 if (search == NULL) {
841 ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
845 if (digest != NULL && len != (size_t)EVP_MD_size(digest)) {
846 ERR_raise_data(ERR_LIB_OSSL_STORE,
847 OSSL_STORE_R_FINGERPRINT_SIZE_DOES_NOT_MATCH_DIGEST,
848 "%s size is %d, fingerprint size is %zu",
849 EVP_MD_name(digest), EVP_MD_size(digest), len);
853 search->search_type = OSSL_STORE_SEARCH_BY_KEY_FINGERPRINT;
854 search->digest = digest;
855 search->string = bytes;
856 search->stringlength = len;
860 OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_alias(const char *alias)
862 OSSL_STORE_SEARCH *search = OPENSSL_zalloc(sizeof(*search));
864 if (search == NULL) {
865 ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
869 search->search_type = OSSL_STORE_SEARCH_BY_ALIAS;
870 search->string = (const unsigned char *)alias;
871 search->stringlength = strlen(alias);
875 /* Search term destructor */
876 void OSSL_STORE_SEARCH_free(OSSL_STORE_SEARCH *search)
878 OPENSSL_free(search);
881 /* Search term accessors */
882 int OSSL_STORE_SEARCH_get_type(const OSSL_STORE_SEARCH *criterion)
884 return criterion->search_type;
887 X509_NAME *OSSL_STORE_SEARCH_get0_name(const OSSL_STORE_SEARCH *criterion)
889 return criterion->name;
892 const ASN1_INTEGER *OSSL_STORE_SEARCH_get0_serial(const OSSL_STORE_SEARCH
895 return criterion->serial;
898 const unsigned char *OSSL_STORE_SEARCH_get0_bytes(const OSSL_STORE_SEARCH
899 *criterion, size_t *length)
901 *length = criterion->stringlength;
902 return criterion->string;
905 const char *OSSL_STORE_SEARCH_get0_string(const OSSL_STORE_SEARCH *criterion)
907 return (const char *)criterion->string;
910 const EVP_MD *OSSL_STORE_SEARCH_get0_digest(const OSSL_STORE_SEARCH *criterion)
912 return criterion->digest;
915 OSSL_STORE_CTX *OSSL_STORE_attach(BIO *bp, const char *scheme,
916 OPENSSL_CTX *libctx, const char *propq,
917 const UI_METHOD *ui_method, void *ui_data,
918 OSSL_STORE_post_process_info_fn post_process,
919 void *post_process_data)
921 const OSSL_STORE_LOADER *loader = NULL;
922 OSSL_STORE_LOADER *fetched_loader = NULL;
923 OSSL_STORE_LOADER_CTX *loader_ctx = NULL;
924 OSSL_STORE_CTX *ctx = NULL;
929 OSSL_TRACE1(STORE, "Looking up scheme %s\n", scheme);
930 #ifndef OPENSSL_NO_DEPRECATED_3_0
931 if ((loader = ossl_store_get0_loader_int(scheme)) != NULL)
932 loader_ctx = loader->attach(loader, bp, libctx, propq,
937 OSSL_STORE_LOADER_fetch(scheme, libctx, propq)) != NULL) {
938 const OSSL_PROVIDER *provider =
939 OSSL_STORE_LOADER_provider(fetched_loader);
940 void *provctx = OSSL_PROVIDER_get0_provider_ctx(provider);
943 fetched_loader->p_attach(provctx, (OSSL_CORE_BIO *)bp)) == NULL) {
944 OSSL_STORE_LOADER_free(fetched_loader);
945 fetched_loader = NULL;
946 } else if (propq != NULL) {
947 OSSL_PARAM params[] = {
948 OSSL_PARAM_utf8_string(OSSL_STORE_PARAM_PROPERTIES,
953 params[0].data = (void *)propq;
954 if (!fetched_loader->p_set_ctx_params(loader_ctx, params)) {
955 (void)fetched_loader->p_close(loader_ctx);
956 OSSL_STORE_LOADER_free(fetched_loader);
957 fetched_loader = NULL;
960 loader = fetched_loader;
963 if (loader_ctx == NULL)
966 if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL) {
967 ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
971 (void)ossl_pw_set_ui_method(&ctx->pwdata, ui_method, ui_data);
972 ctx->fetched_loader = fetched_loader;
973 ctx->loader = loader;
974 ctx->loader_ctx = loader_ctx;
975 ctx->post_process = post_process;
976 ctx->post_process_data = post_process_data;