1b077aed3SPierre Pronchery /*
2*e7be843bSPierre Pronchery * Copyright 2020-2025 The OpenSSL Project Authors. All Rights Reserved.
3b077aed3SPierre Pronchery *
4b077aed3SPierre Pronchery * Licensed under the Apache License 2.0 (the "License"). You may not use
5b077aed3SPierre Pronchery * this file except in compliance with the License. You can obtain a copy
6b077aed3SPierre Pronchery * in the file LICENSE in the source distribution or at
7b077aed3SPierre Pronchery * https://www.openssl.org/source/license.html
8b077aed3SPierre Pronchery */
9b077aed3SPierre Pronchery
10b077aed3SPierre Pronchery #include <openssl/core_names.h>
11b077aed3SPierre Pronchery #include <openssl/core_object.h>
12b077aed3SPierre Pronchery #include <openssl/provider.h>
13b077aed3SPierre Pronchery #include <openssl/evp.h>
14b077aed3SPierre Pronchery #include <openssl/ui.h>
15b077aed3SPierre Pronchery #include <openssl/decoder.h>
16b077aed3SPierre Pronchery #include <openssl/safestack.h>
17b077aed3SPierre Pronchery #include <openssl/trace.h>
18b077aed3SPierre Pronchery #include "crypto/evp.h"
19b077aed3SPierre Pronchery #include "crypto/decoder.h"
20*e7be843bSPierre Pronchery #include "crypto/evp/evp_local.h"
21*e7be843bSPierre Pronchery #include "crypto/lhash.h"
22b077aed3SPierre Pronchery #include "encoder_local.h"
23*e7be843bSPierre Pronchery #include "internal/namemap.h"
24*e7be843bSPierre Pronchery #include "internal/sizes.h"
25b077aed3SPierre Pronchery
OSSL_DECODER_CTX_set_passphrase(OSSL_DECODER_CTX * ctx,const unsigned char * kstr,size_t klen)26b077aed3SPierre Pronchery int OSSL_DECODER_CTX_set_passphrase(OSSL_DECODER_CTX *ctx,
27b077aed3SPierre Pronchery const unsigned char *kstr,
28b077aed3SPierre Pronchery size_t klen)
29b077aed3SPierre Pronchery {
30b077aed3SPierre Pronchery return ossl_pw_set_passphrase(&ctx->pwdata, kstr, klen);
31b077aed3SPierre Pronchery }
32b077aed3SPierre Pronchery
OSSL_DECODER_CTX_set_passphrase_ui(OSSL_DECODER_CTX * ctx,const UI_METHOD * ui_method,void * ui_data)33b077aed3SPierre Pronchery int OSSL_DECODER_CTX_set_passphrase_ui(OSSL_DECODER_CTX *ctx,
34b077aed3SPierre Pronchery const UI_METHOD *ui_method,
35b077aed3SPierre Pronchery void *ui_data)
36b077aed3SPierre Pronchery {
37b077aed3SPierre Pronchery return ossl_pw_set_ui_method(&ctx->pwdata, ui_method, ui_data);
38b077aed3SPierre Pronchery }
39b077aed3SPierre Pronchery
OSSL_DECODER_CTX_set_pem_password_cb(OSSL_DECODER_CTX * ctx,pem_password_cb * cb,void * cbarg)40b077aed3SPierre Pronchery int OSSL_DECODER_CTX_set_pem_password_cb(OSSL_DECODER_CTX *ctx,
41b077aed3SPierre Pronchery pem_password_cb *cb, void *cbarg)
42b077aed3SPierre Pronchery {
43b077aed3SPierre Pronchery return ossl_pw_set_pem_password_cb(&ctx->pwdata, cb, cbarg);
44b077aed3SPierre Pronchery }
45b077aed3SPierre Pronchery
OSSL_DECODER_CTX_set_passphrase_cb(OSSL_DECODER_CTX * ctx,OSSL_PASSPHRASE_CALLBACK * cb,void * cbarg)46b077aed3SPierre Pronchery int OSSL_DECODER_CTX_set_passphrase_cb(OSSL_DECODER_CTX *ctx,
47b077aed3SPierre Pronchery OSSL_PASSPHRASE_CALLBACK *cb,
48b077aed3SPierre Pronchery void *cbarg)
49b077aed3SPierre Pronchery {
50b077aed3SPierre Pronchery return ossl_pw_set_ossl_passphrase_cb(&ctx->pwdata, cb, cbarg);
51b077aed3SPierre Pronchery }
52b077aed3SPierre Pronchery
53b077aed3SPierre Pronchery /*
54b077aed3SPierre Pronchery * Support for OSSL_DECODER_CTX_new_for_pkey:
55b077aed3SPierre Pronchery * The construct data, and collecting keymgmt information for it
56b077aed3SPierre Pronchery */
57b077aed3SPierre Pronchery
58b077aed3SPierre Pronchery DEFINE_STACK_OF(EVP_KEYMGMT)
59b077aed3SPierre Pronchery
60b077aed3SPierre Pronchery struct decoder_pkey_data_st {
61b077aed3SPierre Pronchery OSSL_LIB_CTX *libctx;
62b077aed3SPierre Pronchery char *propq;
63b077aed3SPierre Pronchery int selection;
64b077aed3SPierre Pronchery
65b077aed3SPierre Pronchery STACK_OF(EVP_KEYMGMT) *keymgmts;
66b077aed3SPierre Pronchery char *object_type; /* recorded object data type, may be NULL */
67b077aed3SPierre Pronchery void **object; /* Where the result should end up */
68*e7be843bSPierre Pronchery OSSL_DECODER_CTX *ctx; /* The parent decoder context */
69b077aed3SPierre Pronchery };
70b077aed3SPierre Pronchery
decoder_construct_pkey(OSSL_DECODER_INSTANCE * decoder_inst,const OSSL_PARAM * params,void * construct_data)71b077aed3SPierre Pronchery static int decoder_construct_pkey(OSSL_DECODER_INSTANCE *decoder_inst,
72b077aed3SPierre Pronchery const OSSL_PARAM *params,
73b077aed3SPierre Pronchery void *construct_data)
74b077aed3SPierre Pronchery {
75b077aed3SPierre Pronchery struct decoder_pkey_data_st *data = construct_data;
76b077aed3SPierre Pronchery OSSL_DECODER *decoder = OSSL_DECODER_INSTANCE_get_decoder(decoder_inst);
77b077aed3SPierre Pronchery void *decoderctx = OSSL_DECODER_INSTANCE_get_decoder_ctx(decoder_inst);
78b077aed3SPierre Pronchery const OSSL_PROVIDER *decoder_prov = OSSL_DECODER_get0_provider(decoder);
79b077aed3SPierre Pronchery EVP_KEYMGMT *keymgmt = NULL;
80b077aed3SPierre Pronchery const OSSL_PROVIDER *keymgmt_prov = NULL;
81b077aed3SPierre Pronchery int i, end;
82b077aed3SPierre Pronchery /*
83b077aed3SPierre Pronchery * |object_ref| points to a provider reference to an object, its exact
84b077aed3SPierre Pronchery * contents entirely opaque to us, but may be passed to any provider
85b077aed3SPierre Pronchery * function that expects this (such as OSSL_FUNC_keymgmt_load().
86b077aed3SPierre Pronchery *
87b077aed3SPierre Pronchery * This pointer is considered volatile, i.e. whatever it points at
88b077aed3SPierre Pronchery * is assumed to be freed as soon as this function returns.
89b077aed3SPierre Pronchery */
90b077aed3SPierre Pronchery void *object_ref = NULL;
91b077aed3SPierre Pronchery size_t object_ref_sz = 0;
92b077aed3SPierre Pronchery const OSSL_PARAM *p;
93b077aed3SPierre Pronchery
94b077aed3SPierre Pronchery p = OSSL_PARAM_locate_const(params, OSSL_OBJECT_PARAM_DATA_TYPE);
95b077aed3SPierre Pronchery if (p != NULL) {
96b077aed3SPierre Pronchery char *object_type = NULL;
97b077aed3SPierre Pronchery
98b077aed3SPierre Pronchery if (!OSSL_PARAM_get_utf8_string(p, &object_type, 0))
99b077aed3SPierre Pronchery return 0;
100b077aed3SPierre Pronchery OPENSSL_free(data->object_type);
101b077aed3SPierre Pronchery data->object_type = object_type;
102b077aed3SPierre Pronchery }
103b077aed3SPierre Pronchery
104b077aed3SPierre Pronchery /*
105b077aed3SPierre Pronchery * For stuff that should end up in an EVP_PKEY, we only accept an object
106b077aed3SPierre Pronchery * reference for the moment. This enforces that the key data itself
107b077aed3SPierre Pronchery * remains with the provider.
108b077aed3SPierre Pronchery */
109b077aed3SPierre Pronchery p = OSSL_PARAM_locate_const(params, OSSL_OBJECT_PARAM_REFERENCE);
110b077aed3SPierre Pronchery if (p == NULL || p->data_type != OSSL_PARAM_OCTET_STRING)
111b077aed3SPierre Pronchery return 0;
112b077aed3SPierre Pronchery object_ref = p->data;
113b077aed3SPierre Pronchery object_ref_sz = p->data_size;
114b077aed3SPierre Pronchery
115b077aed3SPierre Pronchery /*
116b077aed3SPierre Pronchery * First, we try to find a keymgmt that comes from the same provider as
117b077aed3SPierre Pronchery * the decoder that passed the params.
118b077aed3SPierre Pronchery */
119b077aed3SPierre Pronchery end = sk_EVP_KEYMGMT_num(data->keymgmts);
120b077aed3SPierre Pronchery for (i = 0; i < end; i++) {
121b077aed3SPierre Pronchery keymgmt = sk_EVP_KEYMGMT_value(data->keymgmts, i);
122b077aed3SPierre Pronchery keymgmt_prov = EVP_KEYMGMT_get0_provider(keymgmt);
123b077aed3SPierre Pronchery
124b077aed3SPierre Pronchery if (keymgmt_prov == decoder_prov
125b077aed3SPierre Pronchery && evp_keymgmt_has_load(keymgmt)
126b077aed3SPierre Pronchery && EVP_KEYMGMT_is_a(keymgmt, data->object_type))
127b077aed3SPierre Pronchery break;
128b077aed3SPierre Pronchery }
129b077aed3SPierre Pronchery if (i < end) {
130b077aed3SPierre Pronchery /* To allow it to be freed further down */
131b077aed3SPierre Pronchery if (!EVP_KEYMGMT_up_ref(keymgmt))
132b077aed3SPierre Pronchery return 0;
133b077aed3SPierre Pronchery } else if ((keymgmt = EVP_KEYMGMT_fetch(data->libctx,
134b077aed3SPierre Pronchery data->object_type,
135b077aed3SPierre Pronchery data->propq)) != NULL) {
136b077aed3SPierre Pronchery keymgmt_prov = EVP_KEYMGMT_get0_provider(keymgmt);
137b077aed3SPierre Pronchery }
138b077aed3SPierre Pronchery
139b077aed3SPierre Pronchery if (keymgmt != NULL) {
140b077aed3SPierre Pronchery EVP_PKEY *pkey = NULL;
141b077aed3SPierre Pronchery void *keydata = NULL;
142b077aed3SPierre Pronchery
143b077aed3SPierre Pronchery /*
144b077aed3SPierre Pronchery * If the EVP_KEYMGMT and the OSSL_DECODER are from the
145b077aed3SPierre Pronchery * same provider, we assume that the KEYMGMT has a key loading
146b077aed3SPierre Pronchery * function that can handle the provider reference we hold.
147b077aed3SPierre Pronchery *
148b077aed3SPierre Pronchery * Otherwise, we export from the decoder and import the
149b077aed3SPierre Pronchery * result in the keymgmt.
150b077aed3SPierre Pronchery */
151b077aed3SPierre Pronchery if (keymgmt_prov == decoder_prov) {
152b077aed3SPierre Pronchery keydata = evp_keymgmt_load(keymgmt, object_ref, object_ref_sz);
153b077aed3SPierre Pronchery } else {
154b077aed3SPierre Pronchery struct evp_keymgmt_util_try_import_data_st import_data;
155b077aed3SPierre Pronchery
156b077aed3SPierre Pronchery import_data.keymgmt = keymgmt;
157b077aed3SPierre Pronchery import_data.keydata = NULL;
1586f1af0d7SPierre Pronchery if (data->selection == 0)
1596f1af0d7SPierre Pronchery /* import/export functions do not tolerate 0 selection */
1606f1af0d7SPierre Pronchery import_data.selection = OSSL_KEYMGMT_SELECT_ALL;
1616f1af0d7SPierre Pronchery else
162b077aed3SPierre Pronchery import_data.selection = data->selection;
163b077aed3SPierre Pronchery
164b077aed3SPierre Pronchery /*
165b077aed3SPierre Pronchery * No need to check for errors here, the value of
166b077aed3SPierre Pronchery * |import_data.keydata| is as much an indicator.
167b077aed3SPierre Pronchery */
168b077aed3SPierre Pronchery (void)decoder->export_object(decoderctx,
169b077aed3SPierre Pronchery object_ref, object_ref_sz,
170b077aed3SPierre Pronchery &evp_keymgmt_util_try_import,
171b077aed3SPierre Pronchery &import_data);
172b077aed3SPierre Pronchery keydata = import_data.keydata;
173b077aed3SPierre Pronchery import_data.keydata = NULL;
174b077aed3SPierre Pronchery }
175*e7be843bSPierre Pronchery /*
176*e7be843bSPierre Pronchery * When load or import fails, because this is not an acceptable key
177*e7be843bSPierre Pronchery * (despite the provided key material being syntactically valid), the
178*e7be843bSPierre Pronchery * reason why the key is rejected would be lost, unless we signal a
179*e7be843bSPierre Pronchery * hard error, and suppress resetting for another try.
180*e7be843bSPierre Pronchery */
181*e7be843bSPierre Pronchery if (keydata == NULL)
182*e7be843bSPierre Pronchery ossl_decoder_ctx_set_harderr(data->ctx);
183b077aed3SPierre Pronchery
184b077aed3SPierre Pronchery if (keydata != NULL
185b077aed3SPierre Pronchery && (pkey = evp_keymgmt_util_make_pkey(keymgmt, keydata)) == NULL)
186b077aed3SPierre Pronchery evp_keymgmt_freedata(keymgmt, keydata);
187b077aed3SPierre Pronchery
188b077aed3SPierre Pronchery *data->object = pkey;
189b077aed3SPierre Pronchery
190b077aed3SPierre Pronchery /*
191b077aed3SPierre Pronchery * evp_keymgmt_util_make_pkey() increments the reference count when
192b077aed3SPierre Pronchery * assigning the EVP_PKEY, so we can free the keymgmt here.
193b077aed3SPierre Pronchery */
194b077aed3SPierre Pronchery EVP_KEYMGMT_free(keymgmt);
195b077aed3SPierre Pronchery }
196b077aed3SPierre Pronchery /*
197b077aed3SPierre Pronchery * We successfully looked through, |*ctx->object| determines if we
198b077aed3SPierre Pronchery * actually found something.
199b077aed3SPierre Pronchery */
200b077aed3SPierre Pronchery return (*data->object != NULL);
201b077aed3SPierre Pronchery }
202b077aed3SPierre Pronchery
decoder_clean_pkey_construct_arg(void * construct_data)203b077aed3SPierre Pronchery static void decoder_clean_pkey_construct_arg(void *construct_data)
204b077aed3SPierre Pronchery {
205b077aed3SPierre Pronchery struct decoder_pkey_data_st *data = construct_data;
206b077aed3SPierre Pronchery
207b077aed3SPierre Pronchery if (data != NULL) {
208b077aed3SPierre Pronchery sk_EVP_KEYMGMT_pop_free(data->keymgmts, EVP_KEYMGMT_free);
209b077aed3SPierre Pronchery OPENSSL_free(data->propq);
210b077aed3SPierre Pronchery OPENSSL_free(data->object_type);
211b077aed3SPierre Pronchery OPENSSL_free(data);
212b077aed3SPierre Pronchery }
213b077aed3SPierre Pronchery }
214b077aed3SPierre Pronchery
215*e7be843bSPierre Pronchery struct collect_data_st {
216*e7be843bSPierre Pronchery OSSL_LIB_CTX *libctx;
217b077aed3SPierre Pronchery OSSL_DECODER_CTX *ctx;
218b077aed3SPierre Pronchery
219*e7be843bSPierre Pronchery const char *keytype; /* the keytype requested, if any */
220*e7be843bSPierre Pronchery int keytype_id; /* if keytype_resolved is set, keymgmt name_id; else 0 */
221*e7be843bSPierre Pronchery int sm2_id; /* if keytype_resolved is set and EC, SM2 name_id; else 0 */
222*e7be843bSPierre Pronchery int total; /* number of matching results */
223*e7be843bSPierre Pronchery char error_occurred;
224*e7be843bSPierre Pronchery char keytype_resolved;
225*e7be843bSPierre Pronchery
226*e7be843bSPierre Pronchery STACK_OF(EVP_KEYMGMT) *keymgmts;
227b077aed3SPierre Pronchery };
228b077aed3SPierre Pronchery
collect_decoder_keymgmt(EVP_KEYMGMT * keymgmt,OSSL_DECODER * decoder,void * provctx,struct collect_data_st * data)229*e7be843bSPierre Pronchery static void collect_decoder_keymgmt(EVP_KEYMGMT *keymgmt, OSSL_DECODER *decoder,
230*e7be843bSPierre Pronchery void *provctx, struct collect_data_st *data)
231b077aed3SPierre Pronchery {
232b077aed3SPierre Pronchery void *decoderctx = NULL;
233b077aed3SPierre Pronchery OSSL_DECODER_INSTANCE *di = NULL;
234b077aed3SPierre Pronchery
235*e7be843bSPierre Pronchery /*
236*e7be843bSPierre Pronchery * We already checked the EVP_KEYMGMT is applicable in check_keymgmt so we
237*e7be843bSPierre Pronchery * don't check it again here.
238*e7be843bSPierre Pronchery */
239*e7be843bSPierre Pronchery
240*e7be843bSPierre Pronchery if (keymgmt->name_id != decoder->base.id)
241*e7be843bSPierre Pronchery /* Mismatch is not an error, continue. */
242*e7be843bSPierre Pronchery return;
243*e7be843bSPierre Pronchery
244b077aed3SPierre Pronchery if ((decoderctx = decoder->newctx(provctx)) == NULL) {
245b077aed3SPierre Pronchery data->error_occurred = 1;
246b077aed3SPierre Pronchery return;
247b077aed3SPierre Pronchery }
248*e7be843bSPierre Pronchery
249b077aed3SPierre Pronchery if ((di = ossl_decoder_instance_new(decoder, decoderctx)) == NULL) {
250b077aed3SPierre Pronchery decoder->freectx(decoderctx);
251b077aed3SPierre Pronchery data->error_occurred = 1;
252b077aed3SPierre Pronchery return;
253b077aed3SPierre Pronchery }
254b077aed3SPierre Pronchery
255*e7be843bSPierre Pronchery /*
256*e7be843bSPierre Pronchery * Input types must be compatible, but we must accept DER encoders when the
257*e7be843bSPierre Pronchery * start input type is "PEM".
258*e7be843bSPierre Pronchery */
259*e7be843bSPierre Pronchery if (data->ctx->start_input_type != NULL
260*e7be843bSPierre Pronchery && di->input_type != NULL
261*e7be843bSPierre Pronchery && OPENSSL_strcasecmp(di->input_type, data->ctx->start_input_type) != 0
262*e7be843bSPierre Pronchery && (OPENSSL_strcasecmp(di->input_type, "DER") != 0
263*e7be843bSPierre Pronchery || OPENSSL_strcasecmp(data->ctx->start_input_type, "PEM") != 0)) {
264*e7be843bSPierre Pronchery /* Mismatch is not an error, continue. */
265*e7be843bSPierre Pronchery ossl_decoder_instance_free(di);
266*e7be843bSPierre Pronchery return;
267*e7be843bSPierre Pronchery }
268*e7be843bSPierre Pronchery
269b077aed3SPierre Pronchery OSSL_TRACE_BEGIN(DECODER) {
270b077aed3SPierre Pronchery BIO_printf(trc_out,
271b077aed3SPierre Pronchery "(ctx %p) Checking out decoder %p:\n"
272b077aed3SPierre Pronchery " %s with %s\n",
273b077aed3SPierre Pronchery (void *)data->ctx, (void *)decoder,
274b077aed3SPierre Pronchery OSSL_DECODER_get0_name(decoder),
275b077aed3SPierre Pronchery OSSL_DECODER_get0_properties(decoder));
276b077aed3SPierre Pronchery } OSSL_TRACE_END(DECODER);
277b077aed3SPierre Pronchery
278b077aed3SPierre Pronchery if (!ossl_decoder_ctx_add_decoder_inst(data->ctx, di)) {
279b077aed3SPierre Pronchery ossl_decoder_instance_free(di);
280b077aed3SPierre Pronchery data->error_occurred = 1;
281b077aed3SPierre Pronchery return;
282b077aed3SPierre Pronchery }
283b077aed3SPierre Pronchery
284*e7be843bSPierre Pronchery ++data->total;
285*e7be843bSPierre Pronchery }
286*e7be843bSPierre Pronchery
collect_decoder(OSSL_DECODER * decoder,void * arg)287*e7be843bSPierre Pronchery static void collect_decoder(OSSL_DECODER *decoder, void *arg)
288*e7be843bSPierre Pronchery {
289*e7be843bSPierre Pronchery struct collect_data_st *data = arg;
290*e7be843bSPierre Pronchery STACK_OF(EVP_KEYMGMT) *keymgmts = data->keymgmts;
291*e7be843bSPierre Pronchery int i, end_i;
292*e7be843bSPierre Pronchery EVP_KEYMGMT *keymgmt;
293*e7be843bSPierre Pronchery const OSSL_PROVIDER *prov;
294*e7be843bSPierre Pronchery void *provctx;
295*e7be843bSPierre Pronchery
296*e7be843bSPierre Pronchery if (data->error_occurred)
297*e7be843bSPierre Pronchery return;
298*e7be843bSPierre Pronchery
299*e7be843bSPierre Pronchery prov = OSSL_DECODER_get0_provider(decoder);
300*e7be843bSPierre Pronchery provctx = OSSL_PROVIDER_get0_provider_ctx(prov);
301*e7be843bSPierre Pronchery
302*e7be843bSPierre Pronchery /*
303*e7be843bSPierre Pronchery * Either the caller didn't give us a selection, or if they did, the decoder
304*e7be843bSPierre Pronchery * must tell us if it supports that selection to be accepted. If the decoder
305*e7be843bSPierre Pronchery * doesn't have |does_selection|, it's seen as taking anything.
306*e7be843bSPierre Pronchery */
307*e7be843bSPierre Pronchery if (decoder->does_selection != NULL
308*e7be843bSPierre Pronchery && !decoder->does_selection(provctx, data->ctx->selection))
309*e7be843bSPierre Pronchery return;
310*e7be843bSPierre Pronchery
311*e7be843bSPierre Pronchery OSSL_TRACE_BEGIN(DECODER) {
312*e7be843bSPierre Pronchery BIO_printf(trc_out,
313*e7be843bSPierre Pronchery "(ctx %p) Checking out decoder %p:\n"
314*e7be843bSPierre Pronchery " %s with %s\n",
315*e7be843bSPierre Pronchery (void *)data->ctx, (void *)decoder,
316*e7be843bSPierre Pronchery OSSL_DECODER_get0_name(decoder),
317*e7be843bSPierre Pronchery OSSL_DECODER_get0_properties(decoder));
318*e7be843bSPierre Pronchery } OSSL_TRACE_END(DECODER);
319*e7be843bSPierre Pronchery
320*e7be843bSPierre Pronchery end_i = sk_EVP_KEYMGMT_num(keymgmts);
321*e7be843bSPierre Pronchery for (i = 0; i < end_i; ++i) {
322*e7be843bSPierre Pronchery keymgmt = sk_EVP_KEYMGMT_value(keymgmts, i);
323*e7be843bSPierre Pronchery
324*e7be843bSPierre Pronchery collect_decoder_keymgmt(keymgmt, decoder, provctx, data);
325*e7be843bSPierre Pronchery if (data->error_occurred)
326b077aed3SPierre Pronchery return;
327b077aed3SPierre Pronchery }
328b077aed3SPierre Pronchery }
329b077aed3SPierre Pronchery
330*e7be843bSPierre Pronchery /*
331*e7be843bSPierre Pronchery * Is this EVP_KEYMGMT applicable given the key type given in the call to
332*e7be843bSPierre Pronchery * ossl_decoder_ctx_setup_for_pkey (if any)?
333*e7be843bSPierre Pronchery */
check_keymgmt(EVP_KEYMGMT * keymgmt,struct collect_data_st * data)334*e7be843bSPierre Pronchery static int check_keymgmt(EVP_KEYMGMT *keymgmt, struct collect_data_st *data)
335*e7be843bSPierre Pronchery {
336*e7be843bSPierre Pronchery /* If no keytype was specified, everything matches. */
337*e7be843bSPierre Pronchery if (data->keytype == NULL)
338*e7be843bSPierre Pronchery return 1;
339*e7be843bSPierre Pronchery
340*e7be843bSPierre Pronchery if (!data->keytype_resolved) {
341*e7be843bSPierre Pronchery /* We haven't cached the IDs from the keytype string yet. */
342*e7be843bSPierre Pronchery OSSL_NAMEMAP *namemap = ossl_namemap_stored(data->libctx);
343*e7be843bSPierre Pronchery data->keytype_id = ossl_namemap_name2num(namemap, data->keytype);
344*e7be843bSPierre Pronchery
345*e7be843bSPierre Pronchery /*
346*e7be843bSPierre Pronchery * If keytype is a value ambiguously used for both EC and SM2,
347*e7be843bSPierre Pronchery * collect the ID for SM2 as well.
348*e7be843bSPierre Pronchery */
349*e7be843bSPierre Pronchery if (data->keytype_id != 0
350*e7be843bSPierre Pronchery && (strcmp(data->keytype, "id-ecPublicKey") == 0
351*e7be843bSPierre Pronchery || strcmp(data->keytype, "1.2.840.10045.2.1") == 0))
352*e7be843bSPierre Pronchery data->sm2_id = ossl_namemap_name2num(namemap, "SM2");
353*e7be843bSPierre Pronchery
354*e7be843bSPierre Pronchery /*
355*e7be843bSPierre Pronchery * If keytype_id is zero the name was not found, but we still
356*e7be843bSPierre Pronchery * set keytype_resolved to avoid trying all this again.
357*e7be843bSPierre Pronchery */
358*e7be843bSPierre Pronchery data->keytype_resolved = 1;
359b077aed3SPierre Pronchery }
360b077aed3SPierre Pronchery
361*e7be843bSPierre Pronchery /* Specified keytype could not be resolved, so nothing matches. */
362*e7be843bSPierre Pronchery if (data->keytype_id == 0)
363*e7be843bSPierre Pronchery return 0;
364*e7be843bSPierre Pronchery
365*e7be843bSPierre Pronchery /* Does not match the keytype specified, so skip. */
366*e7be843bSPierre Pronchery if (keymgmt->name_id != data->keytype_id
367*e7be843bSPierre Pronchery && keymgmt->name_id != data->sm2_id)
368*e7be843bSPierre Pronchery return 0;
369*e7be843bSPierre Pronchery
370*e7be843bSPierre Pronchery return 1;
371*e7be843bSPierre Pronchery }
372*e7be843bSPierre Pronchery
collect_keymgmt(EVP_KEYMGMT * keymgmt,void * arg)373*e7be843bSPierre Pronchery static void collect_keymgmt(EVP_KEYMGMT *keymgmt, void *arg)
374*e7be843bSPierre Pronchery {
375*e7be843bSPierre Pronchery struct collect_data_st *data = arg;
376*e7be843bSPierre Pronchery
377*e7be843bSPierre Pronchery if (!check_keymgmt(keymgmt, data))
378*e7be843bSPierre Pronchery return;
379*e7be843bSPierre Pronchery
380*e7be843bSPierre Pronchery /*
381*e7be843bSPierre Pronchery * We have to ref EVP_KEYMGMT here because in the success case,
382*e7be843bSPierre Pronchery * data->keymgmts is referenced by the constructor we register in the
383*e7be843bSPierre Pronchery * OSSL_DECODER_CTX. The registered cleanup function
384*e7be843bSPierre Pronchery * (decoder_clean_pkey_construct_arg) unrefs every element of the stack and
385*e7be843bSPierre Pronchery * frees it.
386*e7be843bSPierre Pronchery */
387*e7be843bSPierre Pronchery if (!EVP_KEYMGMT_up_ref(keymgmt))
388*e7be843bSPierre Pronchery return;
389*e7be843bSPierre Pronchery
390*e7be843bSPierre Pronchery if (sk_EVP_KEYMGMT_push(data->keymgmts, keymgmt) <= 0) {
391*e7be843bSPierre Pronchery EVP_KEYMGMT_free(keymgmt);
392*e7be843bSPierre Pronchery data->error_occurred = 1;
393*e7be843bSPierre Pronchery }
394*e7be843bSPierre Pronchery }
395*e7be843bSPierre Pronchery
396*e7be843bSPierre Pronchery /*
397*e7be843bSPierre Pronchery * This function does the actual binding of decoders to the OSSL_DECODER_CTX. It
398*e7be843bSPierre Pronchery * searches for decoders matching 'keytype', which is a string like "RSA", "DH",
399*e7be843bSPierre Pronchery * etc. If 'keytype' is NULL, decoders for all keytypes are bound.
400*e7be843bSPierre Pronchery */
ossl_decoder_ctx_setup_for_pkey(OSSL_DECODER_CTX * ctx,const char * keytype,OSSL_LIB_CTX * libctx,const char * propquery)401*e7be843bSPierre Pronchery static int ossl_decoder_ctx_setup_for_pkey(OSSL_DECODER_CTX *ctx,
402*e7be843bSPierre Pronchery const char *keytype,
403b077aed3SPierre Pronchery OSSL_LIB_CTX *libctx,
404b077aed3SPierre Pronchery const char *propquery)
405b077aed3SPierre Pronchery {
406b077aed3SPierre Pronchery int ok = 0;
407*e7be843bSPierre Pronchery struct decoder_pkey_data_st *process_data = NULL;
408*e7be843bSPierre Pronchery struct collect_data_st collect_data = { NULL };
409*e7be843bSPierre Pronchery STACK_OF(EVP_KEYMGMT) *keymgmts = NULL;
410b077aed3SPierre Pronchery
411b077aed3SPierre Pronchery OSSL_TRACE_BEGIN(DECODER) {
412*e7be843bSPierre Pronchery const char *input_type = ctx->start_input_type;
413*e7be843bSPierre Pronchery const char *input_structure = ctx->input_structure;
414*e7be843bSPierre Pronchery
415b077aed3SPierre Pronchery BIO_printf(trc_out,
416b077aed3SPierre Pronchery "(ctx %p) Looking for decoders producing %s%s%s%s%s%s\n",
417b077aed3SPierre Pronchery (void *)ctx,
418b077aed3SPierre Pronchery keytype != NULL ? keytype : "",
419b077aed3SPierre Pronchery keytype != NULL ? " keys" : "keys of any type",
420b077aed3SPierre Pronchery input_type != NULL ? " from " : "",
421b077aed3SPierre Pronchery input_type != NULL ? input_type : "",
422b077aed3SPierre Pronchery input_structure != NULL ? " with " : "",
423b077aed3SPierre Pronchery input_structure != NULL ? input_structure : "");
424b077aed3SPierre Pronchery } OSSL_TRACE_END(DECODER);
425b077aed3SPierre Pronchery
426*e7be843bSPierre Pronchery /* Allocate data. */
427*e7be843bSPierre Pronchery if ((process_data = OPENSSL_zalloc(sizeof(*process_data))) == NULL)
428*e7be843bSPierre Pronchery goto err;
429*e7be843bSPierre Pronchery if ((propquery != NULL
430*e7be843bSPierre Pronchery && (process_data->propq = OPENSSL_strdup(propquery)) == NULL))
431*e7be843bSPierre Pronchery goto err;
432*e7be843bSPierre Pronchery
433*e7be843bSPierre Pronchery /* Allocate our list of EVP_KEYMGMTs. */
434*e7be843bSPierre Pronchery keymgmts = sk_EVP_KEYMGMT_new_null();
435*e7be843bSPierre Pronchery if (keymgmts == NULL) {
436*e7be843bSPierre Pronchery ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_CRYPTO_LIB);
437b077aed3SPierre Pronchery goto err;
438b077aed3SPierre Pronchery }
439b077aed3SPierre Pronchery
440*e7be843bSPierre Pronchery process_data->object = NULL;
441b077aed3SPierre Pronchery process_data->libctx = libctx;
442b077aed3SPierre Pronchery process_data->selection = ctx->selection;
443*e7be843bSPierre Pronchery process_data->keymgmts = keymgmts;
444b077aed3SPierre Pronchery
445b077aed3SPierre Pronchery /*
446*e7be843bSPierre Pronchery * Enumerate all keymgmts into a stack.
447*e7be843bSPierre Pronchery *
448*e7be843bSPierre Pronchery * We could nest EVP_KEYMGMT_do_all_provided inside
449*e7be843bSPierre Pronchery * OSSL_DECODER_do_all_provided or vice versa but these functions become
450*e7be843bSPierre Pronchery * bottlenecks if called repeatedly, which is why we collect the
451*e7be843bSPierre Pronchery * EVP_KEYMGMTs into a stack here and call both functions only once.
452*e7be843bSPierre Pronchery *
453*e7be843bSPierre Pronchery * We resolve the keytype string to a name ID so we don't have to resolve it
454*e7be843bSPierre Pronchery * multiple times, avoiding repeated calls to EVP_KEYMGMT_is_a, which is a
455*e7be843bSPierre Pronchery * performance bottleneck. However, we do this lazily on the first call to
456*e7be843bSPierre Pronchery * collect_keymgmt made by EVP_KEYMGMT_do_all_provided, rather than do it
457*e7be843bSPierre Pronchery * upfront, as this ensures that the names for all loaded providers have
458*e7be843bSPierre Pronchery * been registered by the time we try to resolve the keytype string.
459b077aed3SPierre Pronchery */
460*e7be843bSPierre Pronchery collect_data.ctx = ctx;
461*e7be843bSPierre Pronchery collect_data.libctx = libctx;
462*e7be843bSPierre Pronchery collect_data.keymgmts = keymgmts;
463*e7be843bSPierre Pronchery collect_data.keytype = keytype;
464*e7be843bSPierre Pronchery EVP_KEYMGMT_do_all_provided(libctx, collect_keymgmt, &collect_data);
465*e7be843bSPierre Pronchery
466*e7be843bSPierre Pronchery if (collect_data.error_occurred)
467b077aed3SPierre Pronchery goto err;
468b077aed3SPierre Pronchery
469*e7be843bSPierre Pronchery /* Enumerate all matching decoders. */
470*e7be843bSPierre Pronchery OSSL_DECODER_do_all_provided(libctx, collect_decoder, &collect_data);
471b077aed3SPierre Pronchery
472*e7be843bSPierre Pronchery if (collect_data.error_occurred)
473b077aed3SPierre Pronchery goto err;
474b077aed3SPierre Pronchery
475b077aed3SPierre Pronchery OSSL_TRACE_BEGIN(DECODER) {
476b077aed3SPierre Pronchery BIO_printf(trc_out,
477b077aed3SPierre Pronchery "(ctx %p) Got %d decoders producing keys\n",
478*e7be843bSPierre Pronchery (void *)ctx, collect_data.total);
479b077aed3SPierre Pronchery } OSSL_TRACE_END(DECODER);
480b077aed3SPierre Pronchery
481*e7be843bSPierre Pronchery /*
482*e7be843bSPierre Pronchery * Finish initializing the decoder context. If one or more decoders matched
483*e7be843bSPierre Pronchery * above then the number of decoders attached to the OSSL_DECODER_CTX will
484*e7be843bSPierre Pronchery * be nonzero. Else nothing was found and we do nothing.
485*e7be843bSPierre Pronchery */
486b077aed3SPierre Pronchery if (OSSL_DECODER_CTX_get_num_decoders(ctx) != 0) {
487b077aed3SPierre Pronchery if (!OSSL_DECODER_CTX_set_construct(ctx, decoder_construct_pkey)
488b077aed3SPierre Pronchery || !OSSL_DECODER_CTX_set_construct_data(ctx, process_data)
489b077aed3SPierre Pronchery || !OSSL_DECODER_CTX_set_cleanup(ctx,
490b077aed3SPierre Pronchery decoder_clean_pkey_construct_arg))
491b077aed3SPierre Pronchery goto err;
492b077aed3SPierre Pronchery
493b077aed3SPierre Pronchery process_data = NULL; /* Avoid it being freed */
494b077aed3SPierre Pronchery }
495b077aed3SPierre Pronchery
496b077aed3SPierre Pronchery ok = 1;
497b077aed3SPierre Pronchery err:
498b077aed3SPierre Pronchery decoder_clean_pkey_construct_arg(process_data);
499b077aed3SPierre Pronchery return ok;
500b077aed3SPierre Pronchery }
501b077aed3SPierre Pronchery
502*e7be843bSPierre Pronchery /* Only const here because deep_copy requires it */
keymgmt_dup(const EVP_KEYMGMT * keymgmt)503*e7be843bSPierre Pronchery static EVP_KEYMGMT *keymgmt_dup(const EVP_KEYMGMT *keymgmt)
504*e7be843bSPierre Pronchery {
505*e7be843bSPierre Pronchery if (!EVP_KEYMGMT_up_ref((EVP_KEYMGMT *)keymgmt))
506*e7be843bSPierre Pronchery return NULL;
507*e7be843bSPierre Pronchery
508*e7be843bSPierre Pronchery return (EVP_KEYMGMT *)keymgmt;
509*e7be843bSPierre Pronchery }
510*e7be843bSPierre Pronchery
511*e7be843bSPierre Pronchery /*
512*e7be843bSPierre Pronchery * Duplicates a template OSSL_DECODER_CTX that has been setup for an EVP_PKEY
513*e7be843bSPierre Pronchery * operation and sets up the duplicate for a new operation.
514*e7be843bSPierre Pronchery * It does not duplicate the pwdata on the assumption that this does not form
515*e7be843bSPierre Pronchery * part of the template. That is set up later.
516*e7be843bSPierre Pronchery */
517*e7be843bSPierre Pronchery static OSSL_DECODER_CTX *
ossl_decoder_ctx_for_pkey_dup(OSSL_DECODER_CTX * src,EVP_PKEY ** pkey,const char * input_type,const char * input_structure)518*e7be843bSPierre Pronchery ossl_decoder_ctx_for_pkey_dup(OSSL_DECODER_CTX *src,
519*e7be843bSPierre Pronchery EVP_PKEY **pkey,
520*e7be843bSPierre Pronchery const char *input_type,
521*e7be843bSPierre Pronchery const char *input_structure)
522*e7be843bSPierre Pronchery {
523*e7be843bSPierre Pronchery OSSL_DECODER_CTX *dest;
524*e7be843bSPierre Pronchery struct decoder_pkey_data_st *process_data_src, *process_data_dest = NULL;
525*e7be843bSPierre Pronchery
526*e7be843bSPierre Pronchery if (src == NULL)
527*e7be843bSPierre Pronchery return NULL;
528*e7be843bSPierre Pronchery
529*e7be843bSPierre Pronchery if ((dest = OSSL_DECODER_CTX_new()) == NULL) {
530*e7be843bSPierre Pronchery ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_OSSL_DECODER_LIB);
531*e7be843bSPierre Pronchery return NULL;
532*e7be843bSPierre Pronchery }
533*e7be843bSPierre Pronchery
534*e7be843bSPierre Pronchery if (!OSSL_DECODER_CTX_set_input_type(dest, input_type)
535*e7be843bSPierre Pronchery || !OSSL_DECODER_CTX_set_input_structure(dest, input_structure)) {
536*e7be843bSPierre Pronchery ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_OSSL_DECODER_LIB);
537*e7be843bSPierre Pronchery goto err;
538*e7be843bSPierre Pronchery }
539*e7be843bSPierre Pronchery dest->selection = src->selection;
540*e7be843bSPierre Pronchery
541*e7be843bSPierre Pronchery if (src->decoder_insts != NULL) {
542*e7be843bSPierre Pronchery dest->decoder_insts
543*e7be843bSPierre Pronchery = sk_OSSL_DECODER_INSTANCE_deep_copy(src->decoder_insts,
544*e7be843bSPierre Pronchery ossl_decoder_instance_dup,
545*e7be843bSPierre Pronchery ossl_decoder_instance_free);
546*e7be843bSPierre Pronchery if (dest->decoder_insts == NULL) {
547*e7be843bSPierre Pronchery ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_OSSL_DECODER_LIB);
548*e7be843bSPierre Pronchery goto err;
549*e7be843bSPierre Pronchery }
550*e7be843bSPierre Pronchery }
551*e7be843bSPierre Pronchery
552*e7be843bSPierre Pronchery if (!OSSL_DECODER_CTX_set_construct(dest,
553*e7be843bSPierre Pronchery OSSL_DECODER_CTX_get_construct(src))) {
554*e7be843bSPierre Pronchery ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_OSSL_DECODER_LIB);
555*e7be843bSPierre Pronchery goto err;
556*e7be843bSPierre Pronchery }
557*e7be843bSPierre Pronchery
558*e7be843bSPierre Pronchery process_data_src = OSSL_DECODER_CTX_get_construct_data(src);
559*e7be843bSPierre Pronchery if (process_data_src != NULL) {
560*e7be843bSPierre Pronchery process_data_dest = OPENSSL_zalloc(sizeof(*process_data_dest));
561*e7be843bSPierre Pronchery if (process_data_dest == NULL) {
562*e7be843bSPierre Pronchery ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_CRYPTO_LIB);
563*e7be843bSPierre Pronchery goto err;
564*e7be843bSPierre Pronchery }
565*e7be843bSPierre Pronchery if (process_data_src->propq != NULL) {
566*e7be843bSPierre Pronchery process_data_dest->propq = OPENSSL_strdup(process_data_src->propq);
567*e7be843bSPierre Pronchery if (process_data_dest->propq == NULL) {
568*e7be843bSPierre Pronchery ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_CRYPTO_LIB);
569*e7be843bSPierre Pronchery goto err;
570*e7be843bSPierre Pronchery }
571*e7be843bSPierre Pronchery }
572*e7be843bSPierre Pronchery
573*e7be843bSPierre Pronchery if (process_data_src->keymgmts != NULL) {
574*e7be843bSPierre Pronchery process_data_dest->keymgmts
575*e7be843bSPierre Pronchery = sk_EVP_KEYMGMT_deep_copy(process_data_src->keymgmts,
576*e7be843bSPierre Pronchery keymgmt_dup,
577*e7be843bSPierre Pronchery EVP_KEYMGMT_free);
578*e7be843bSPierre Pronchery if (process_data_dest->keymgmts == NULL) {
579*e7be843bSPierre Pronchery ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_EVP_LIB);
580*e7be843bSPierre Pronchery goto err;
581*e7be843bSPierre Pronchery }
582*e7be843bSPierre Pronchery }
583*e7be843bSPierre Pronchery
584*e7be843bSPierre Pronchery process_data_dest->object = (void **)pkey;
585*e7be843bSPierre Pronchery process_data_dest->libctx = process_data_src->libctx;
586*e7be843bSPierre Pronchery process_data_dest->selection = process_data_src->selection;
587*e7be843bSPierre Pronchery process_data_dest->ctx = dest;
588*e7be843bSPierre Pronchery if (!OSSL_DECODER_CTX_set_construct_data(dest, process_data_dest)) {
589*e7be843bSPierre Pronchery ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_OSSL_DECODER_LIB);
590*e7be843bSPierre Pronchery goto err;
591*e7be843bSPierre Pronchery }
592*e7be843bSPierre Pronchery process_data_dest = NULL;
593*e7be843bSPierre Pronchery }
594*e7be843bSPierre Pronchery
595*e7be843bSPierre Pronchery if (!OSSL_DECODER_CTX_set_cleanup(dest,
596*e7be843bSPierre Pronchery OSSL_DECODER_CTX_get_cleanup(src))) {
597*e7be843bSPierre Pronchery ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_OSSL_DECODER_LIB);
598*e7be843bSPierre Pronchery goto err;
599*e7be843bSPierre Pronchery }
600*e7be843bSPierre Pronchery
601*e7be843bSPierre Pronchery return dest;
602*e7be843bSPierre Pronchery err:
603*e7be843bSPierre Pronchery decoder_clean_pkey_construct_arg(process_data_dest);
604*e7be843bSPierre Pronchery OSSL_DECODER_CTX_free(dest);
605*e7be843bSPierre Pronchery return NULL;
606*e7be843bSPierre Pronchery }
607*e7be843bSPierre Pronchery
608*e7be843bSPierre Pronchery typedef struct {
609*e7be843bSPierre Pronchery char *input_type;
610*e7be843bSPierre Pronchery char *input_structure;
611*e7be843bSPierre Pronchery char *keytype;
612*e7be843bSPierre Pronchery int selection;
613*e7be843bSPierre Pronchery char *propquery;
614*e7be843bSPierre Pronchery OSSL_DECODER_CTX *template;
615*e7be843bSPierre Pronchery } DECODER_CACHE_ENTRY;
616*e7be843bSPierre Pronchery
617*e7be843bSPierre Pronchery DEFINE_LHASH_OF_EX(DECODER_CACHE_ENTRY);
618*e7be843bSPierre Pronchery
619*e7be843bSPierre Pronchery typedef struct {
620*e7be843bSPierre Pronchery CRYPTO_RWLOCK *lock;
621*e7be843bSPierre Pronchery LHASH_OF(DECODER_CACHE_ENTRY) *hashtable;
622*e7be843bSPierre Pronchery } DECODER_CACHE;
623*e7be843bSPierre Pronchery
decoder_cache_entry_free(DECODER_CACHE_ENTRY * entry)624*e7be843bSPierre Pronchery static void decoder_cache_entry_free(DECODER_CACHE_ENTRY *entry)
625*e7be843bSPierre Pronchery {
626*e7be843bSPierre Pronchery if (entry == NULL)
627*e7be843bSPierre Pronchery return;
628*e7be843bSPierre Pronchery OPENSSL_free(entry->input_type);
629*e7be843bSPierre Pronchery OPENSSL_free(entry->input_structure);
630*e7be843bSPierre Pronchery OPENSSL_free(entry->keytype);
631*e7be843bSPierre Pronchery OPENSSL_free(entry->propquery);
632*e7be843bSPierre Pronchery OSSL_DECODER_CTX_free(entry->template);
633*e7be843bSPierre Pronchery OPENSSL_free(entry);
634*e7be843bSPierre Pronchery }
635*e7be843bSPierre Pronchery
decoder_cache_entry_hash(const DECODER_CACHE_ENTRY * cache)636*e7be843bSPierre Pronchery static unsigned long decoder_cache_entry_hash(const DECODER_CACHE_ENTRY *cache)
637*e7be843bSPierre Pronchery {
638*e7be843bSPierre Pronchery unsigned long hash = 17;
639*e7be843bSPierre Pronchery
640*e7be843bSPierre Pronchery hash = (hash * 23)
641*e7be843bSPierre Pronchery + (cache->propquery == NULL
642*e7be843bSPierre Pronchery ? 0 : ossl_lh_strcasehash(cache->propquery));
643*e7be843bSPierre Pronchery hash = (hash * 23)
644*e7be843bSPierre Pronchery + (cache->input_structure == NULL
645*e7be843bSPierre Pronchery ? 0 : ossl_lh_strcasehash(cache->input_structure));
646*e7be843bSPierre Pronchery hash = (hash * 23)
647*e7be843bSPierre Pronchery + (cache->input_type == NULL
648*e7be843bSPierre Pronchery ? 0 : ossl_lh_strcasehash(cache->input_type));
649*e7be843bSPierre Pronchery hash = (hash * 23)
650*e7be843bSPierre Pronchery + (cache->keytype == NULL
651*e7be843bSPierre Pronchery ? 0 : ossl_lh_strcasehash(cache->keytype));
652*e7be843bSPierre Pronchery
653*e7be843bSPierre Pronchery hash ^= cache->selection;
654*e7be843bSPierre Pronchery
655*e7be843bSPierre Pronchery return hash;
656*e7be843bSPierre Pronchery }
657*e7be843bSPierre Pronchery
nullstrcmp(const char * a,const char * b,int casecmp)658*e7be843bSPierre Pronchery static ossl_inline int nullstrcmp(const char *a, const char *b, int casecmp)
659*e7be843bSPierre Pronchery {
660*e7be843bSPierre Pronchery if (a == NULL || b == NULL) {
661*e7be843bSPierre Pronchery if (a == NULL) {
662*e7be843bSPierre Pronchery if (b == NULL)
663*e7be843bSPierre Pronchery return 0;
664*e7be843bSPierre Pronchery else
665*e7be843bSPierre Pronchery return 1;
666*e7be843bSPierre Pronchery } else {
667*e7be843bSPierre Pronchery return -1;
668*e7be843bSPierre Pronchery }
669*e7be843bSPierre Pronchery } else {
670*e7be843bSPierre Pronchery if (casecmp)
671*e7be843bSPierre Pronchery return OPENSSL_strcasecmp(a, b);
672*e7be843bSPierre Pronchery else
673*e7be843bSPierre Pronchery return strcmp(a, b);
674*e7be843bSPierre Pronchery }
675*e7be843bSPierre Pronchery }
676*e7be843bSPierre Pronchery
decoder_cache_entry_cmp(const DECODER_CACHE_ENTRY * a,const DECODER_CACHE_ENTRY * b)677*e7be843bSPierre Pronchery static int decoder_cache_entry_cmp(const DECODER_CACHE_ENTRY *a,
678*e7be843bSPierre Pronchery const DECODER_CACHE_ENTRY *b)
679*e7be843bSPierre Pronchery {
680*e7be843bSPierre Pronchery int cmp;
681*e7be843bSPierre Pronchery
682*e7be843bSPierre Pronchery if (a->selection != b->selection)
683*e7be843bSPierre Pronchery return (a->selection < b->selection) ? -1 : 1;
684*e7be843bSPierre Pronchery
685*e7be843bSPierre Pronchery cmp = nullstrcmp(a->keytype, b->keytype, 1);
686*e7be843bSPierre Pronchery if (cmp != 0)
687*e7be843bSPierre Pronchery return cmp;
688*e7be843bSPierre Pronchery
689*e7be843bSPierre Pronchery cmp = nullstrcmp(a->input_type, b->input_type, 1);
690*e7be843bSPierre Pronchery if (cmp != 0)
691*e7be843bSPierre Pronchery return cmp;
692*e7be843bSPierre Pronchery
693*e7be843bSPierre Pronchery cmp = nullstrcmp(a->input_structure, b->input_structure, 1);
694*e7be843bSPierre Pronchery if (cmp != 0)
695*e7be843bSPierre Pronchery return cmp;
696*e7be843bSPierre Pronchery
697*e7be843bSPierre Pronchery cmp = nullstrcmp(a->propquery, b->propquery, 0);
698*e7be843bSPierre Pronchery
699*e7be843bSPierre Pronchery return cmp;
700*e7be843bSPierre Pronchery }
701*e7be843bSPierre Pronchery
ossl_decoder_cache_new(OSSL_LIB_CTX * ctx)702*e7be843bSPierre Pronchery void *ossl_decoder_cache_new(OSSL_LIB_CTX *ctx)
703*e7be843bSPierre Pronchery {
704*e7be843bSPierre Pronchery DECODER_CACHE *cache = OPENSSL_malloc(sizeof(*cache));
705*e7be843bSPierre Pronchery
706*e7be843bSPierre Pronchery if (cache == NULL)
707*e7be843bSPierre Pronchery return NULL;
708*e7be843bSPierre Pronchery
709*e7be843bSPierre Pronchery cache->lock = CRYPTO_THREAD_lock_new();
710*e7be843bSPierre Pronchery if (cache->lock == NULL) {
711*e7be843bSPierre Pronchery OPENSSL_free(cache);
712*e7be843bSPierre Pronchery return NULL;
713*e7be843bSPierre Pronchery }
714*e7be843bSPierre Pronchery cache->hashtable = lh_DECODER_CACHE_ENTRY_new(decoder_cache_entry_hash,
715*e7be843bSPierre Pronchery decoder_cache_entry_cmp);
716*e7be843bSPierre Pronchery if (cache->hashtable == NULL) {
717*e7be843bSPierre Pronchery CRYPTO_THREAD_lock_free(cache->lock);
718*e7be843bSPierre Pronchery OPENSSL_free(cache);
719*e7be843bSPierre Pronchery return NULL;
720*e7be843bSPierre Pronchery }
721*e7be843bSPierre Pronchery
722*e7be843bSPierre Pronchery return cache;
723*e7be843bSPierre Pronchery }
724*e7be843bSPierre Pronchery
ossl_decoder_cache_free(void * vcache)725*e7be843bSPierre Pronchery void ossl_decoder_cache_free(void *vcache)
726*e7be843bSPierre Pronchery {
727*e7be843bSPierre Pronchery DECODER_CACHE *cache = (DECODER_CACHE *)vcache;
728*e7be843bSPierre Pronchery
729*e7be843bSPierre Pronchery lh_DECODER_CACHE_ENTRY_doall(cache->hashtable, decoder_cache_entry_free);
730*e7be843bSPierre Pronchery lh_DECODER_CACHE_ENTRY_free(cache->hashtable);
731*e7be843bSPierre Pronchery CRYPTO_THREAD_lock_free(cache->lock);
732*e7be843bSPierre Pronchery OPENSSL_free(cache);
733*e7be843bSPierre Pronchery }
734*e7be843bSPierre Pronchery
735*e7be843bSPierre Pronchery /*
736*e7be843bSPierre Pronchery * Called whenever a provider gets activated/deactivated. In that case the
737*e7be843bSPierre Pronchery * decoders that are available might change so we flush our cache.
738*e7be843bSPierre Pronchery */
ossl_decoder_cache_flush(OSSL_LIB_CTX * libctx)739*e7be843bSPierre Pronchery int ossl_decoder_cache_flush(OSSL_LIB_CTX *libctx)
740*e7be843bSPierre Pronchery {
741*e7be843bSPierre Pronchery DECODER_CACHE *cache
742*e7be843bSPierre Pronchery = ossl_lib_ctx_get_data(libctx, OSSL_LIB_CTX_DECODER_CACHE_INDEX);
743*e7be843bSPierre Pronchery
744*e7be843bSPierre Pronchery if (cache == NULL)
745*e7be843bSPierre Pronchery return 0;
746*e7be843bSPierre Pronchery
747*e7be843bSPierre Pronchery
748*e7be843bSPierre Pronchery if (!CRYPTO_THREAD_write_lock(cache->lock)) {
749*e7be843bSPierre Pronchery ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_OSSL_DECODER_LIB);
750*e7be843bSPierre Pronchery return 0;
751*e7be843bSPierre Pronchery }
752*e7be843bSPierre Pronchery
753*e7be843bSPierre Pronchery lh_DECODER_CACHE_ENTRY_doall(cache->hashtable, decoder_cache_entry_free);
754*e7be843bSPierre Pronchery lh_DECODER_CACHE_ENTRY_flush(cache->hashtable);
755*e7be843bSPierre Pronchery
756*e7be843bSPierre Pronchery CRYPTO_THREAD_unlock(cache->lock);
757*e7be843bSPierre Pronchery return 1;
758*e7be843bSPierre Pronchery }
759*e7be843bSPierre Pronchery
760b077aed3SPierre Pronchery OSSL_DECODER_CTX *
OSSL_DECODER_CTX_new_for_pkey(EVP_PKEY ** pkey,const char * input_type,const char * input_structure,const char * keytype,int selection,OSSL_LIB_CTX * libctx,const char * propquery)761b077aed3SPierre Pronchery OSSL_DECODER_CTX_new_for_pkey(EVP_PKEY **pkey,
762b077aed3SPierre Pronchery const char *input_type,
763b077aed3SPierre Pronchery const char *input_structure,
764b077aed3SPierre Pronchery const char *keytype, int selection,
765b077aed3SPierre Pronchery OSSL_LIB_CTX *libctx, const char *propquery)
766b077aed3SPierre Pronchery {
767b077aed3SPierre Pronchery OSSL_DECODER_CTX *ctx = NULL;
768*e7be843bSPierre Pronchery OSSL_PARAM decoder_params[] = {
769*e7be843bSPierre Pronchery OSSL_PARAM_END,
770*e7be843bSPierre Pronchery OSSL_PARAM_END,
771*e7be843bSPierre Pronchery OSSL_PARAM_END
772*e7be843bSPierre Pronchery };
773*e7be843bSPierre Pronchery DECODER_CACHE *cache
774*e7be843bSPierre Pronchery = ossl_lib_ctx_get_data(libctx, OSSL_LIB_CTX_DECODER_CACHE_INDEX);
775*e7be843bSPierre Pronchery DECODER_CACHE_ENTRY cacheent, *res, *newcache = NULL;
776*e7be843bSPierre Pronchery int i = 0;
777*e7be843bSPierre Pronchery
778*e7be843bSPierre Pronchery if (cache == NULL) {
779*e7be843bSPierre Pronchery ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_OSSL_DECODER_LIB);
780*e7be843bSPierre Pronchery return NULL;
781*e7be843bSPierre Pronchery }
782*e7be843bSPierre Pronchery if (input_structure != NULL)
783*e7be843bSPierre Pronchery decoder_params[i++] =
784*e7be843bSPierre Pronchery OSSL_PARAM_construct_utf8_string(OSSL_OBJECT_PARAM_DATA_STRUCTURE,
785*e7be843bSPierre Pronchery (char *)input_structure, 0);
786*e7be843bSPierre Pronchery if (propquery != NULL)
787*e7be843bSPierre Pronchery decoder_params[i++] =
788*e7be843bSPierre Pronchery OSSL_PARAM_construct_utf8_string(OSSL_DECODER_PARAM_PROPERTIES,
789*e7be843bSPierre Pronchery (char *)propquery, 0);
790*e7be843bSPierre Pronchery
791*e7be843bSPierre Pronchery /* It is safe to cast away the const here */
792*e7be843bSPierre Pronchery cacheent.input_type = (char *)input_type;
793*e7be843bSPierre Pronchery cacheent.input_structure = (char *)input_structure;
794*e7be843bSPierre Pronchery cacheent.keytype = (char *)keytype;
795*e7be843bSPierre Pronchery cacheent.selection = selection;
796*e7be843bSPierre Pronchery cacheent.propquery = (char *)propquery;
797*e7be843bSPierre Pronchery
798*e7be843bSPierre Pronchery if (!CRYPTO_THREAD_read_lock(cache->lock)) {
799*e7be843bSPierre Pronchery ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_CRYPTO_LIB);
800*e7be843bSPierre Pronchery return NULL;
801*e7be843bSPierre Pronchery }
802*e7be843bSPierre Pronchery
803*e7be843bSPierre Pronchery /* First see if we have a template OSSL_DECODER_CTX */
804*e7be843bSPierre Pronchery res = lh_DECODER_CACHE_ENTRY_retrieve(cache->hashtable, &cacheent);
805*e7be843bSPierre Pronchery
806*e7be843bSPierre Pronchery if (res == NULL) {
807*e7be843bSPierre Pronchery /*
808*e7be843bSPierre Pronchery * There is no template so we will have to construct one. This will be
809*e7be843bSPierre Pronchery * time consuming so release the lock and we will later upgrade it to a
810*e7be843bSPierre Pronchery * write lock.
811*e7be843bSPierre Pronchery */
812*e7be843bSPierre Pronchery CRYPTO_THREAD_unlock(cache->lock);
813b077aed3SPierre Pronchery
814b077aed3SPierre Pronchery if ((ctx = OSSL_DECODER_CTX_new()) == NULL) {
815*e7be843bSPierre Pronchery ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_OSSL_DECODER_LIB);
816b077aed3SPierre Pronchery return NULL;
817b077aed3SPierre Pronchery }
818b077aed3SPierre Pronchery
819b077aed3SPierre Pronchery OSSL_TRACE_BEGIN(DECODER) {
820b077aed3SPierre Pronchery BIO_printf(trc_out,
821b077aed3SPierre Pronchery "(ctx %p) Looking for %s decoders with selection %d\n",
822b077aed3SPierre Pronchery (void *)ctx, keytype, selection);
823b077aed3SPierre Pronchery BIO_printf(trc_out, " input type: %s, input structure: %s\n",
824b077aed3SPierre Pronchery input_type, input_structure);
825b077aed3SPierre Pronchery } OSSL_TRACE_END(DECODER);
826b077aed3SPierre Pronchery
827b077aed3SPierre Pronchery if (OSSL_DECODER_CTX_set_input_type(ctx, input_type)
828b077aed3SPierre Pronchery && OSSL_DECODER_CTX_set_input_structure(ctx, input_structure)
829b077aed3SPierre Pronchery && OSSL_DECODER_CTX_set_selection(ctx, selection)
830*e7be843bSPierre Pronchery && ossl_decoder_ctx_setup_for_pkey(ctx, keytype, libctx, propquery)
831*e7be843bSPierre Pronchery && OSSL_DECODER_CTX_add_extra(ctx, libctx, propquery)
832*e7be843bSPierre Pronchery && (propquery == NULL
833*e7be843bSPierre Pronchery || OSSL_DECODER_CTX_set_params(ctx, decoder_params))) {
834b077aed3SPierre Pronchery OSSL_TRACE_BEGIN(DECODER) {
835b077aed3SPierre Pronchery BIO_printf(trc_out, "(ctx %p) Got %d decoders\n",
836b077aed3SPierre Pronchery (void *)ctx, OSSL_DECODER_CTX_get_num_decoders(ctx));
837b077aed3SPierre Pronchery } OSSL_TRACE_END(DECODER);
838*e7be843bSPierre Pronchery } else {
839*e7be843bSPierre Pronchery ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_OSSL_DECODER_LIB);
840*e7be843bSPierre Pronchery OSSL_DECODER_CTX_free(ctx);
841*e7be843bSPierre Pronchery return NULL;
842b077aed3SPierre Pronchery }
843b077aed3SPierre Pronchery
844*e7be843bSPierre Pronchery newcache = OPENSSL_zalloc(sizeof(*newcache));
845*e7be843bSPierre Pronchery if (newcache == NULL) {
846*e7be843bSPierre Pronchery OSSL_DECODER_CTX_free(ctx);
847*e7be843bSPierre Pronchery return NULL;
848*e7be843bSPierre Pronchery }
849*e7be843bSPierre Pronchery
850*e7be843bSPierre Pronchery if (input_type != NULL) {
851*e7be843bSPierre Pronchery newcache->input_type = OPENSSL_strdup(input_type);
852*e7be843bSPierre Pronchery if (newcache->input_type == NULL)
853*e7be843bSPierre Pronchery goto err;
854*e7be843bSPierre Pronchery }
855*e7be843bSPierre Pronchery if (input_structure != NULL) {
856*e7be843bSPierre Pronchery newcache->input_structure = OPENSSL_strdup(input_structure);
857*e7be843bSPierre Pronchery if (newcache->input_structure == NULL)
858*e7be843bSPierre Pronchery goto err;
859*e7be843bSPierre Pronchery }
860*e7be843bSPierre Pronchery if (keytype != NULL) {
861*e7be843bSPierre Pronchery newcache->keytype = OPENSSL_strdup(keytype);
862*e7be843bSPierre Pronchery if (newcache->keytype == NULL)
863*e7be843bSPierre Pronchery goto err;
864*e7be843bSPierre Pronchery }
865*e7be843bSPierre Pronchery if (propquery != NULL) {
866*e7be843bSPierre Pronchery newcache->propquery = OPENSSL_strdup(propquery);
867*e7be843bSPierre Pronchery if (newcache->propquery == NULL)
868*e7be843bSPierre Pronchery goto err;
869*e7be843bSPierre Pronchery }
870*e7be843bSPierre Pronchery newcache->selection = selection;
871*e7be843bSPierre Pronchery newcache->template = ctx;
872*e7be843bSPierre Pronchery
873*e7be843bSPierre Pronchery if (!CRYPTO_THREAD_write_lock(cache->lock)) {
874*e7be843bSPierre Pronchery ctx = NULL;
875*e7be843bSPierre Pronchery ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_CRYPTO_LIB);
876*e7be843bSPierre Pronchery goto err;
877*e7be843bSPierre Pronchery }
878*e7be843bSPierre Pronchery res = lh_DECODER_CACHE_ENTRY_retrieve(cache->hashtable, &cacheent);
879*e7be843bSPierre Pronchery if (res == NULL) {
880*e7be843bSPierre Pronchery (void)lh_DECODER_CACHE_ENTRY_insert(cache->hashtable, newcache);
881*e7be843bSPierre Pronchery if (lh_DECODER_CACHE_ENTRY_error(cache->hashtable)) {
882*e7be843bSPierre Pronchery ctx = NULL;
883*e7be843bSPierre Pronchery ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_CRYPTO_LIB);
884*e7be843bSPierre Pronchery goto err;
885*e7be843bSPierre Pronchery }
886*e7be843bSPierre Pronchery } else {
887*e7be843bSPierre Pronchery /*
888*e7be843bSPierre Pronchery * We raced with another thread to construct this and lost. Free
889*e7be843bSPierre Pronchery * what we just created and use the entry from the hashtable instead
890*e7be843bSPierre Pronchery */
891*e7be843bSPierre Pronchery decoder_cache_entry_free(newcache);
892*e7be843bSPierre Pronchery ctx = res->template;
893*e7be843bSPierre Pronchery }
894*e7be843bSPierre Pronchery } else {
895*e7be843bSPierre Pronchery ctx = res->template;
896*e7be843bSPierre Pronchery }
897*e7be843bSPierre Pronchery
898*e7be843bSPierre Pronchery ctx = ossl_decoder_ctx_for_pkey_dup(ctx, pkey, input_type, input_structure);
899*e7be843bSPierre Pronchery CRYPTO_THREAD_unlock(cache->lock);
900*e7be843bSPierre Pronchery
901*e7be843bSPierre Pronchery return ctx;
902*e7be843bSPierre Pronchery err:
903*e7be843bSPierre Pronchery decoder_cache_entry_free(newcache);
904b077aed3SPierre Pronchery OSSL_DECODER_CTX_free(ctx);
905b077aed3SPierre Pronchery return NULL;
906b077aed3SPierre Pronchery }
907