1 /*
2 * Copyright 2019-2025 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 #include <openssl/crypto.h>
11 #include <openssl/core_dispatch.h>
12 #include <openssl/evp.h>
13 #include <openssl/err.h>
14 #include "internal/provider.h"
15 #include "internal/refcount.h"
16 #include "internal/core.h"
17 #include "crypto/evp.h"
18 #include "evp_local.h"
19
evp_keymgmt_free(void * data)20 static void evp_keymgmt_free(void *data)
21 {
22 EVP_KEYMGMT_free(data);
23 }
24
evp_keymgmt_up_ref(void * data)25 static int evp_keymgmt_up_ref(void *data)
26 {
27 return EVP_KEYMGMT_up_ref(data);
28 }
29
keymgmt_new(void)30 static void *keymgmt_new(void)
31 {
32 EVP_KEYMGMT *keymgmt = NULL;
33
34 if ((keymgmt = OPENSSL_zalloc(sizeof(*keymgmt))) == NULL)
35 return NULL;
36 if (!CRYPTO_NEW_REF(&keymgmt->refcnt, 1)) {
37 EVP_KEYMGMT_free(keymgmt);
38 return NULL;
39 }
40 return keymgmt;
41 }
42
43 #ifndef FIPS_MODULE
help_get_legacy_alg_type_from_keymgmt(const char * keytype,void * arg)44 static void help_get_legacy_alg_type_from_keymgmt(const char *keytype,
45 void *arg)
46 {
47 int *type = arg;
48
49 if (*type == NID_undef)
50 *type = evp_pkey_name2type(keytype);
51 }
52
get_legacy_alg_type_from_keymgmt(const EVP_KEYMGMT * keymgmt)53 static int get_legacy_alg_type_from_keymgmt(const EVP_KEYMGMT *keymgmt)
54 {
55 int type = NID_undef;
56
57 EVP_KEYMGMT_names_do_all(keymgmt, help_get_legacy_alg_type_from_keymgmt,
58 &type);
59 return type;
60 }
61 #endif
62
keymgmt_from_algorithm(int name_id,const OSSL_ALGORITHM * algodef,OSSL_PROVIDER * prov)63 static void *keymgmt_from_algorithm(int name_id,
64 const OSSL_ALGORITHM *algodef,
65 OSSL_PROVIDER *prov)
66 {
67 const OSSL_DISPATCH *fns = algodef->implementation;
68 EVP_KEYMGMT *keymgmt = NULL;
69 int setparamfncnt = 0, getparamfncnt = 0;
70 int setgenparamfncnt = 0;
71 int importfncnt = 0, exportfncnt = 0;
72 int importtypesfncnt = 0, exporttypesfncnt = 0;
73 int getgenparamfncnt = 0;
74
75 if ((keymgmt = keymgmt_new()) == NULL)
76 return NULL;
77
78 keymgmt->name_id = name_id;
79 if ((keymgmt->type_name = ossl_algorithm_get1_first_name(algodef)) == NULL) {
80 EVP_KEYMGMT_free(keymgmt);
81 return NULL;
82 }
83 keymgmt->description = algodef->algorithm_description;
84
85 for (; fns->function_id != 0; fns++) {
86 switch (fns->function_id) {
87 case OSSL_FUNC_KEYMGMT_NEW:
88 if (keymgmt->new == NULL)
89 keymgmt->new = OSSL_FUNC_keymgmt_new(fns);
90 break;
91 case OSSL_FUNC_KEYMGMT_GEN_INIT:
92 if (keymgmt->gen_init == NULL)
93 keymgmt->gen_init = OSSL_FUNC_keymgmt_gen_init(fns);
94 break;
95 case OSSL_FUNC_KEYMGMT_GEN_SET_TEMPLATE:
96 if (keymgmt->gen_set_template == NULL)
97 keymgmt->gen_set_template =
98 OSSL_FUNC_keymgmt_gen_set_template(fns);
99 break;
100 case OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS:
101 if (keymgmt->gen_set_params == NULL) {
102 setgenparamfncnt++;
103 keymgmt->gen_set_params =
104 OSSL_FUNC_keymgmt_gen_set_params(fns);
105 }
106 break;
107 case OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS:
108 if (keymgmt->gen_settable_params == NULL) {
109 setgenparamfncnt++;
110 keymgmt->gen_settable_params =
111 OSSL_FUNC_keymgmt_gen_settable_params(fns);
112 }
113 break;
114 case OSSL_FUNC_KEYMGMT_GEN_GET_PARAMS:
115 if (keymgmt->gen_get_params == NULL) {
116 getgenparamfncnt++;
117 keymgmt->gen_get_params =
118 OSSL_FUNC_keymgmt_gen_get_params(fns);
119 }
120 break;
121 case OSSL_FUNC_KEYMGMT_GEN_GETTABLE_PARAMS:
122 if (keymgmt->gen_gettable_params == NULL) {
123 getgenparamfncnt++;
124 keymgmt->gen_gettable_params =
125 OSSL_FUNC_keymgmt_gen_gettable_params(fns);
126 }
127 break;
128 case OSSL_FUNC_KEYMGMT_GEN:
129 if (keymgmt->gen == NULL)
130 keymgmt->gen = OSSL_FUNC_keymgmt_gen(fns);
131 break;
132 case OSSL_FUNC_KEYMGMT_GEN_CLEANUP:
133 if (keymgmt->gen_cleanup == NULL)
134 keymgmt->gen_cleanup = OSSL_FUNC_keymgmt_gen_cleanup(fns);
135 break;
136 case OSSL_FUNC_KEYMGMT_FREE:
137 if (keymgmt->free == NULL)
138 keymgmt->free = OSSL_FUNC_keymgmt_free(fns);
139 break;
140 case OSSL_FUNC_KEYMGMT_LOAD:
141 if (keymgmt->load == NULL)
142 keymgmt->load = OSSL_FUNC_keymgmt_load(fns);
143 break;
144 case OSSL_FUNC_KEYMGMT_GET_PARAMS:
145 if (keymgmt->get_params == NULL) {
146 getparamfncnt++;
147 keymgmt->get_params = OSSL_FUNC_keymgmt_get_params(fns);
148 }
149 break;
150 case OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS:
151 if (keymgmt->gettable_params == NULL) {
152 getparamfncnt++;
153 keymgmt->gettable_params =
154 OSSL_FUNC_keymgmt_gettable_params(fns);
155 }
156 break;
157 case OSSL_FUNC_KEYMGMT_SET_PARAMS:
158 if (keymgmt->set_params == NULL) {
159 setparamfncnt++;
160 keymgmt->set_params = OSSL_FUNC_keymgmt_set_params(fns);
161 }
162 break;
163 case OSSL_FUNC_KEYMGMT_SETTABLE_PARAMS:
164 if (keymgmt->settable_params == NULL) {
165 setparamfncnt++;
166 keymgmt->settable_params =
167 OSSL_FUNC_keymgmt_settable_params(fns);
168 }
169 break;
170 case OSSL_FUNC_KEYMGMT_QUERY_OPERATION_NAME:
171 if (keymgmt->query_operation_name == NULL)
172 keymgmt->query_operation_name =
173 OSSL_FUNC_keymgmt_query_operation_name(fns);
174 break;
175 case OSSL_FUNC_KEYMGMT_HAS:
176 if (keymgmt->has == NULL)
177 keymgmt->has = OSSL_FUNC_keymgmt_has(fns);
178 break;
179 case OSSL_FUNC_KEYMGMT_DUP:
180 if (keymgmt->dup == NULL)
181 keymgmt->dup = OSSL_FUNC_keymgmt_dup(fns);
182 break;
183 case OSSL_FUNC_KEYMGMT_VALIDATE:
184 if (keymgmt->validate == NULL)
185 keymgmt->validate = OSSL_FUNC_keymgmt_validate(fns);
186 break;
187 case OSSL_FUNC_KEYMGMT_MATCH:
188 if (keymgmt->match == NULL)
189 keymgmt->match = OSSL_FUNC_keymgmt_match(fns);
190 break;
191 case OSSL_FUNC_KEYMGMT_IMPORT:
192 if (keymgmt->import == NULL) {
193 importfncnt++;
194 keymgmt->import = OSSL_FUNC_keymgmt_import(fns);
195 }
196 break;
197 case OSSL_FUNC_KEYMGMT_IMPORT_TYPES:
198 if (keymgmt->import_types == NULL) {
199 if (importtypesfncnt == 0)
200 importfncnt++;
201 importtypesfncnt++;
202 keymgmt->import_types = OSSL_FUNC_keymgmt_import_types(fns);
203 }
204 break;
205 case OSSL_FUNC_KEYMGMT_IMPORT_TYPES_EX:
206 if (keymgmt->import_types_ex == NULL) {
207 if (importtypesfncnt == 0)
208 importfncnt++;
209 importtypesfncnt++;
210 keymgmt->import_types_ex = OSSL_FUNC_keymgmt_import_types_ex(fns);
211 }
212 break;
213 case OSSL_FUNC_KEYMGMT_EXPORT:
214 if (keymgmt->export == NULL) {
215 exportfncnt++;
216 keymgmt->export = OSSL_FUNC_keymgmt_export(fns);
217 }
218 break;
219 case OSSL_FUNC_KEYMGMT_EXPORT_TYPES:
220 if (keymgmt->export_types == NULL) {
221 if (exporttypesfncnt == 0)
222 exportfncnt++;
223 exporttypesfncnt++;
224 keymgmt->export_types = OSSL_FUNC_keymgmt_export_types(fns);
225 }
226 break;
227 case OSSL_FUNC_KEYMGMT_EXPORT_TYPES_EX:
228 if (keymgmt->export_types_ex == NULL) {
229 if (exporttypesfncnt == 0)
230 exportfncnt++;
231 exporttypesfncnt++;
232 keymgmt->export_types_ex = OSSL_FUNC_keymgmt_export_types_ex(fns);
233 }
234 break;
235 }
236 }
237 /*
238 * Try to check that the method is sensible.
239 * At least one constructor and the destructor are MANDATORY
240 * The functions 'has' is MANDATORY
241 * It makes no sense being able to free stuff if you can't create it.
242 * It makes no sense providing OSSL_PARAM descriptors for import and
243 * export if you can't import or export.
244 */
245 if (keymgmt->free == NULL
246 || (keymgmt->new == NULL
247 && keymgmt->gen == NULL
248 && keymgmt->load == NULL)
249 || keymgmt->has == NULL
250 || (getparamfncnt != 0 && getparamfncnt != 2)
251 || (setparamfncnt != 0 && setparamfncnt != 2)
252 || (setgenparamfncnt != 0 && setgenparamfncnt != 2)
253 || (getgenparamfncnt != 0 && getgenparamfncnt != 2)
254 || (importfncnt != 0 && importfncnt != 2)
255 || (exportfncnt != 0 && exportfncnt != 2)
256 || (keymgmt->gen != NULL
257 && (keymgmt->gen_init == NULL
258 || keymgmt->gen_cleanup == NULL))) {
259 EVP_KEYMGMT_free(keymgmt);
260 ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_PROVIDER_FUNCTIONS);
261 return NULL;
262 }
263 keymgmt->prov = prov;
264 if (prov != NULL)
265 ossl_provider_up_ref(prov);
266
267 #ifndef FIPS_MODULE
268 keymgmt->legacy_alg = get_legacy_alg_type_from_keymgmt(keymgmt);
269 #endif
270
271 return keymgmt;
272 }
273
evp_keymgmt_fetch_from_prov(OSSL_PROVIDER * prov,const char * name,const char * properties)274 EVP_KEYMGMT *evp_keymgmt_fetch_from_prov(OSSL_PROVIDER *prov,
275 const char *name,
276 const char *properties)
277 {
278 return evp_generic_fetch_from_prov(prov, OSSL_OP_KEYMGMT,
279 name, properties,
280 keymgmt_from_algorithm,
281 evp_keymgmt_up_ref,
282 evp_keymgmt_free);
283 }
284
EVP_KEYMGMT_fetch(OSSL_LIB_CTX * ctx,const char * algorithm,const char * properties)285 EVP_KEYMGMT *EVP_KEYMGMT_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
286 const char *properties)
287 {
288 return evp_generic_fetch(ctx, OSSL_OP_KEYMGMT, algorithm, properties,
289 keymgmt_from_algorithm,
290 evp_keymgmt_up_ref,
291 evp_keymgmt_free);
292 }
293
EVP_KEYMGMT_up_ref(EVP_KEYMGMT * keymgmt)294 int EVP_KEYMGMT_up_ref(EVP_KEYMGMT *keymgmt)
295 {
296 int ref = 0;
297
298 CRYPTO_UP_REF(&keymgmt->refcnt, &ref);
299 return 1;
300 }
301
EVP_KEYMGMT_free(EVP_KEYMGMT * keymgmt)302 void EVP_KEYMGMT_free(EVP_KEYMGMT *keymgmt)
303 {
304 int ref = 0;
305
306 if (keymgmt == NULL)
307 return;
308
309 CRYPTO_DOWN_REF(&keymgmt->refcnt, &ref);
310 if (ref > 0)
311 return;
312 OPENSSL_free(keymgmt->type_name);
313 ossl_provider_free(keymgmt->prov);
314 CRYPTO_FREE_REF(&keymgmt->refcnt);
315 OPENSSL_free(keymgmt);
316 }
317
EVP_KEYMGMT_get0_provider(const EVP_KEYMGMT * keymgmt)318 const OSSL_PROVIDER *EVP_KEYMGMT_get0_provider(const EVP_KEYMGMT *keymgmt)
319 {
320 return keymgmt->prov;
321 }
322
evp_keymgmt_get_number(const EVP_KEYMGMT * keymgmt)323 int evp_keymgmt_get_number(const EVP_KEYMGMT *keymgmt)
324 {
325 return keymgmt->name_id;
326 }
327
evp_keymgmt_get_legacy_alg(const EVP_KEYMGMT * keymgmt)328 int evp_keymgmt_get_legacy_alg(const EVP_KEYMGMT *keymgmt)
329 {
330 return keymgmt->legacy_alg;
331 }
332
EVP_KEYMGMT_get0_description(const EVP_KEYMGMT * keymgmt)333 const char *EVP_KEYMGMT_get0_description(const EVP_KEYMGMT *keymgmt)
334 {
335 return keymgmt->description;
336 }
337
EVP_KEYMGMT_get0_name(const EVP_KEYMGMT * keymgmt)338 const char *EVP_KEYMGMT_get0_name(const EVP_KEYMGMT *keymgmt)
339 {
340 return keymgmt->type_name;
341 }
342
EVP_KEYMGMT_is_a(const EVP_KEYMGMT * keymgmt,const char * name)343 int EVP_KEYMGMT_is_a(const EVP_KEYMGMT *keymgmt, const char *name)
344 {
345 return keymgmt != NULL
346 && evp_is_a(keymgmt->prov, keymgmt->name_id, NULL, name);
347 }
348
EVP_KEYMGMT_do_all_provided(OSSL_LIB_CTX * libctx,void (* fn)(EVP_KEYMGMT * keymgmt,void * arg),void * arg)349 void EVP_KEYMGMT_do_all_provided(OSSL_LIB_CTX *libctx,
350 void (*fn)(EVP_KEYMGMT *keymgmt, void *arg),
351 void *arg)
352 {
353 evp_generic_do_all(libctx, OSSL_OP_KEYMGMT,
354 (void (*)(void *, void *))fn, arg,
355 keymgmt_from_algorithm,
356 evp_keymgmt_up_ref,
357 evp_keymgmt_free);
358 }
359
EVP_KEYMGMT_names_do_all(const EVP_KEYMGMT * keymgmt,void (* fn)(const char * name,void * data),void * data)360 int EVP_KEYMGMT_names_do_all(const EVP_KEYMGMT *keymgmt,
361 void (*fn)(const char *name, void *data),
362 void *data)
363 {
364 if (keymgmt->prov != NULL)
365 return evp_names_do_all(keymgmt->prov, keymgmt->name_id, fn, data);
366
367 return 1;
368 }
369
370 /*
371 * Internal API that interfaces with the method function pointers
372 */
evp_keymgmt_newdata(const EVP_KEYMGMT * keymgmt)373 void *evp_keymgmt_newdata(const EVP_KEYMGMT *keymgmt)
374 {
375 void *provctx = ossl_provider_ctx(EVP_KEYMGMT_get0_provider(keymgmt));
376
377 /*
378 * 'new' is currently mandatory on its own, but when new
379 * constructors appear, it won't be quite as mandatory,
380 * so we have a check for future cases.
381 */
382 if (keymgmt->new == NULL)
383 return NULL;
384 return keymgmt->new(provctx);
385 }
386
evp_keymgmt_freedata(const EVP_KEYMGMT * keymgmt,void * keydata)387 void evp_keymgmt_freedata(const EVP_KEYMGMT *keymgmt, void *keydata)
388 {
389 /* This is mandatory, no need to check for its presence */
390 keymgmt->free(keydata);
391 }
392
evp_keymgmt_gen_init(const EVP_KEYMGMT * keymgmt,int selection,const OSSL_PARAM params[])393 void *evp_keymgmt_gen_init(const EVP_KEYMGMT *keymgmt, int selection,
394 const OSSL_PARAM params[])
395 {
396 void *provctx = ossl_provider_ctx(EVP_KEYMGMT_get0_provider(keymgmt));
397
398 if (keymgmt->gen_init == NULL)
399 return NULL;
400 return keymgmt->gen_init(provctx, selection, params);
401 }
402
evp_keymgmt_gen_set_template(const EVP_KEYMGMT * keymgmt,void * genctx,void * templ)403 int evp_keymgmt_gen_set_template(const EVP_KEYMGMT *keymgmt, void *genctx,
404 void *templ)
405 {
406 /*
407 * It's arguable if we actually should return success in this case, as
408 * it allows the caller to set a template key, which is then ignored.
409 * However, this is how the legacy methods (EVP_PKEY_METHOD) operate,
410 * so we do this in the interest of backward compatibility.
411 */
412 if (keymgmt->gen_set_template == NULL)
413 return 1;
414 return keymgmt->gen_set_template(genctx, templ);
415 }
416
evp_keymgmt_gen_set_params(const EVP_KEYMGMT * keymgmt,void * genctx,const OSSL_PARAM params[])417 int evp_keymgmt_gen_set_params(const EVP_KEYMGMT *keymgmt, void *genctx,
418 const OSSL_PARAM params[])
419 {
420 if (keymgmt->gen_set_params == NULL)
421 return 0;
422 return keymgmt->gen_set_params(genctx, params);
423 }
424
EVP_KEYMGMT_gen_settable_params(const EVP_KEYMGMT * keymgmt)425 const OSSL_PARAM *EVP_KEYMGMT_gen_settable_params(const EVP_KEYMGMT *keymgmt)
426 {
427 void *provctx = ossl_provider_ctx(EVP_KEYMGMT_get0_provider(keymgmt));
428
429 if (keymgmt->gen_settable_params == NULL)
430 return NULL;
431 return keymgmt->gen_settable_params(NULL, provctx);
432 }
433
evp_keymgmt_gen_get_params(const EVP_KEYMGMT * keymgmt,void * genctx,OSSL_PARAM params[])434 int evp_keymgmt_gen_get_params(const EVP_KEYMGMT *keymgmt, void *genctx,
435 OSSL_PARAM params[])
436 {
437 if (keymgmt->gen_get_params == NULL)
438 return 0;
439 return keymgmt->gen_get_params(genctx, params);
440 }
441
EVP_KEYMGMT_gen_gettable_params(const EVP_KEYMGMT * keymgmt)442 const OSSL_PARAM *EVP_KEYMGMT_gen_gettable_params(const EVP_KEYMGMT *keymgmt)
443 {
444 void *provctx = ossl_provider_ctx(EVP_KEYMGMT_get0_provider(keymgmt));
445
446 if (keymgmt->gen_gettable_params == NULL)
447 return NULL;
448 return keymgmt->gen_gettable_params(NULL, provctx);
449 }
450
evp_keymgmt_gen(const EVP_KEYMGMT * keymgmt,void * genctx,OSSL_CALLBACK * cb,void * cbarg)451 void *evp_keymgmt_gen(const EVP_KEYMGMT *keymgmt, void *genctx,
452 OSSL_CALLBACK *cb, void *cbarg)
453 {
454 void *ret;
455 const char *desc = keymgmt->description != NULL ? keymgmt->description : "";
456
457 if (keymgmt->gen == NULL) {
458 ERR_raise_data(ERR_LIB_EVP, EVP_R_PROVIDER_KEYMGMT_NOT_SUPPORTED,
459 "%s key generation:%s", keymgmt->type_name, desc);
460 return NULL;
461 }
462
463 ERR_set_mark();
464 ret = keymgmt->gen(genctx, cb, cbarg);
465 if (ret == NULL && ERR_count_to_mark() == 0)
466 ERR_raise_data(ERR_LIB_EVP, EVP_R_PROVIDER_KEYMGMT_FAILURE,
467 "%s key generation:%s", keymgmt->type_name, desc);
468 ERR_clear_last_mark();
469 return ret;
470 }
471
evp_keymgmt_gen_cleanup(const EVP_KEYMGMT * keymgmt,void * genctx)472 void evp_keymgmt_gen_cleanup(const EVP_KEYMGMT *keymgmt, void *genctx)
473 {
474 if (keymgmt->gen_cleanup != NULL)
475 keymgmt->gen_cleanup(genctx);
476 }
477
evp_keymgmt_has_load(const EVP_KEYMGMT * keymgmt)478 int evp_keymgmt_has_load(const EVP_KEYMGMT *keymgmt)
479 {
480 return keymgmt != NULL && keymgmt->load != NULL;
481 }
482
evp_keymgmt_load(const EVP_KEYMGMT * keymgmt,const void * objref,size_t objref_sz)483 void *evp_keymgmt_load(const EVP_KEYMGMT *keymgmt,
484 const void *objref, size_t objref_sz)
485 {
486 if (evp_keymgmt_has_load(keymgmt))
487 return keymgmt->load(objref, objref_sz);
488 return NULL;
489 }
490
evp_keymgmt_get_params(const EVP_KEYMGMT * keymgmt,void * keydata,OSSL_PARAM params[])491 int evp_keymgmt_get_params(const EVP_KEYMGMT *keymgmt, void *keydata,
492 OSSL_PARAM params[])
493 {
494 if (keymgmt->get_params == NULL)
495 return 1;
496 return keymgmt->get_params(keydata, params);
497 }
498
EVP_KEYMGMT_gettable_params(const EVP_KEYMGMT * keymgmt)499 const OSSL_PARAM *EVP_KEYMGMT_gettable_params(const EVP_KEYMGMT *keymgmt)
500 {
501 void *provctx = ossl_provider_ctx(EVP_KEYMGMT_get0_provider(keymgmt));
502
503 if (keymgmt->gettable_params == NULL)
504 return NULL;
505 return keymgmt->gettable_params(provctx);
506 }
507
evp_keymgmt_set_params(const EVP_KEYMGMT * keymgmt,void * keydata,const OSSL_PARAM params[])508 int evp_keymgmt_set_params(const EVP_KEYMGMT *keymgmt, void *keydata,
509 const OSSL_PARAM params[])
510 {
511 if (keymgmt->set_params == NULL)
512 return 1;
513 return keymgmt->set_params(keydata, params);
514 }
515
EVP_KEYMGMT_settable_params(const EVP_KEYMGMT * keymgmt)516 const OSSL_PARAM *EVP_KEYMGMT_settable_params(const EVP_KEYMGMT *keymgmt)
517 {
518 void *provctx = ossl_provider_ctx(EVP_KEYMGMT_get0_provider(keymgmt));
519
520 if (keymgmt->settable_params == NULL)
521 return NULL;
522 return keymgmt->settable_params(provctx);
523 }
524
evp_keymgmt_has(const EVP_KEYMGMT * keymgmt,void * keydata,int selection)525 int evp_keymgmt_has(const EVP_KEYMGMT *keymgmt, void *keydata, int selection)
526 {
527 /* This is mandatory, no need to check for its presence */
528 return keymgmt->has(keydata, selection);
529 }
530
evp_keymgmt_validate(const EVP_KEYMGMT * keymgmt,void * keydata,int selection,int checktype)531 int evp_keymgmt_validate(const EVP_KEYMGMT *keymgmt, void *keydata,
532 int selection, int checktype)
533 {
534 /* We assume valid if the implementation doesn't have a function */
535 if (keymgmt->validate == NULL)
536 return 1;
537 return keymgmt->validate(keydata, selection, checktype);
538 }
539
evp_keymgmt_match(const EVP_KEYMGMT * keymgmt,const void * keydata1,const void * keydata2,int selection)540 int evp_keymgmt_match(const EVP_KEYMGMT *keymgmt,
541 const void *keydata1, const void *keydata2,
542 int selection)
543 {
544 /* We assume no match if the implementation doesn't have a function */
545 if (keymgmt->match == NULL)
546 return 0;
547 return keymgmt->match(keydata1, keydata2, selection);
548 }
549
evp_keymgmt_import(const EVP_KEYMGMT * keymgmt,void * keydata,int selection,const OSSL_PARAM params[])550 int evp_keymgmt_import(const EVP_KEYMGMT *keymgmt, void *keydata,
551 int selection, const OSSL_PARAM params[])
552 {
553 if (keymgmt->import == NULL)
554 return 0;
555 return keymgmt->import(keydata, selection, params);
556 }
557
evp_keymgmt_import_types(const EVP_KEYMGMT * keymgmt,int selection)558 const OSSL_PARAM *evp_keymgmt_import_types(const EVP_KEYMGMT *keymgmt,
559 int selection)
560 {
561 void *provctx = ossl_provider_ctx(EVP_KEYMGMT_get0_provider(keymgmt));
562
563 if (keymgmt->import_types_ex != NULL)
564 return keymgmt->import_types_ex(provctx, selection);
565 if (keymgmt->import_types == NULL)
566 return NULL;
567 return keymgmt->import_types(selection);
568 }
569
evp_keymgmt_export(const EVP_KEYMGMT * keymgmt,void * keydata,int selection,OSSL_CALLBACK * param_cb,void * cbarg)570 int evp_keymgmt_export(const EVP_KEYMGMT *keymgmt, void *keydata,
571 int selection, OSSL_CALLBACK *param_cb, void *cbarg)
572 {
573 if (keymgmt->export == NULL)
574 return 0;
575 return keymgmt->export(keydata, selection, param_cb, cbarg);
576 }
577
evp_keymgmt_export_types(const EVP_KEYMGMT * keymgmt,int selection)578 const OSSL_PARAM *evp_keymgmt_export_types(const EVP_KEYMGMT *keymgmt,
579 int selection)
580 {
581 void *provctx = ossl_provider_ctx(EVP_KEYMGMT_get0_provider(keymgmt));
582
583 if (keymgmt->export_types_ex != NULL)
584 return keymgmt->export_types_ex(provctx, selection);
585 if (keymgmt->export_types == NULL)
586 return NULL;
587 return keymgmt->export_types(selection);
588 }
589
evp_keymgmt_dup(const EVP_KEYMGMT * keymgmt,const void * keydata_from,int selection)590 void *evp_keymgmt_dup(const EVP_KEYMGMT *keymgmt, const void *keydata_from,
591 int selection)
592 {
593 /* We assume no dup if the implementation doesn't have a function */
594 if (keymgmt->dup == NULL)
595 return NULL;
596 return keymgmt->dup(keydata_from, selection);
597 }
598