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 ret = keymgmt->gen(genctx, cb, cbarg);
464 if (ret == NULL)
465 ERR_raise_data(ERR_LIB_EVP, EVP_R_PROVIDER_KEYMGMT_FAILURE,
466 "%s key generation:%s", keymgmt->type_name, desc);
467 return ret;
468 }
469
evp_keymgmt_gen_cleanup(const EVP_KEYMGMT * keymgmt,void * genctx)470 void evp_keymgmt_gen_cleanup(const EVP_KEYMGMT *keymgmt, void *genctx)
471 {
472 if (keymgmt->gen_cleanup != NULL)
473 keymgmt->gen_cleanup(genctx);
474 }
475
evp_keymgmt_has_load(const EVP_KEYMGMT * keymgmt)476 int evp_keymgmt_has_load(const EVP_KEYMGMT *keymgmt)
477 {
478 return keymgmt != NULL && keymgmt->load != NULL;
479 }
480
evp_keymgmt_load(const EVP_KEYMGMT * keymgmt,const void * objref,size_t objref_sz)481 void *evp_keymgmt_load(const EVP_KEYMGMT *keymgmt,
482 const void *objref, size_t objref_sz)
483 {
484 if (evp_keymgmt_has_load(keymgmt))
485 return keymgmt->load(objref, objref_sz);
486 return NULL;
487 }
488
evp_keymgmt_get_params(const EVP_KEYMGMT * keymgmt,void * keydata,OSSL_PARAM params[])489 int evp_keymgmt_get_params(const EVP_KEYMGMT *keymgmt, void *keydata,
490 OSSL_PARAM params[])
491 {
492 if (keymgmt->get_params == NULL)
493 return 1;
494 return keymgmt->get_params(keydata, params);
495 }
496
EVP_KEYMGMT_gettable_params(const EVP_KEYMGMT * keymgmt)497 const OSSL_PARAM *EVP_KEYMGMT_gettable_params(const EVP_KEYMGMT *keymgmt)
498 {
499 void *provctx = ossl_provider_ctx(EVP_KEYMGMT_get0_provider(keymgmt));
500
501 if (keymgmt->gettable_params == NULL)
502 return NULL;
503 return keymgmt->gettable_params(provctx);
504 }
505
evp_keymgmt_set_params(const EVP_KEYMGMT * keymgmt,void * keydata,const OSSL_PARAM params[])506 int evp_keymgmt_set_params(const EVP_KEYMGMT *keymgmt, void *keydata,
507 const OSSL_PARAM params[])
508 {
509 if (keymgmt->set_params == NULL)
510 return 1;
511 return keymgmt->set_params(keydata, params);
512 }
513
EVP_KEYMGMT_settable_params(const EVP_KEYMGMT * keymgmt)514 const OSSL_PARAM *EVP_KEYMGMT_settable_params(const EVP_KEYMGMT *keymgmt)
515 {
516 void *provctx = ossl_provider_ctx(EVP_KEYMGMT_get0_provider(keymgmt));
517
518 if (keymgmt->settable_params == NULL)
519 return NULL;
520 return keymgmt->settable_params(provctx);
521 }
522
evp_keymgmt_has(const EVP_KEYMGMT * keymgmt,void * keydata,int selection)523 int evp_keymgmt_has(const EVP_KEYMGMT *keymgmt, void *keydata, int selection)
524 {
525 /* This is mandatory, no need to check for its presence */
526 return keymgmt->has(keydata, selection);
527 }
528
evp_keymgmt_validate(const EVP_KEYMGMT * keymgmt,void * keydata,int selection,int checktype)529 int evp_keymgmt_validate(const EVP_KEYMGMT *keymgmt, void *keydata,
530 int selection, int checktype)
531 {
532 /* We assume valid if the implementation doesn't have a function */
533 if (keymgmt->validate == NULL)
534 return 1;
535 return keymgmt->validate(keydata, selection, checktype);
536 }
537
evp_keymgmt_match(const EVP_KEYMGMT * keymgmt,const void * keydata1,const void * keydata2,int selection)538 int evp_keymgmt_match(const EVP_KEYMGMT *keymgmt,
539 const void *keydata1, const void *keydata2,
540 int selection)
541 {
542 /* We assume no match if the implementation doesn't have a function */
543 if (keymgmt->match == NULL)
544 return 0;
545 return keymgmt->match(keydata1, keydata2, selection);
546 }
547
evp_keymgmt_import(const EVP_KEYMGMT * keymgmt,void * keydata,int selection,const OSSL_PARAM params[])548 int evp_keymgmt_import(const EVP_KEYMGMT *keymgmt, void *keydata,
549 int selection, const OSSL_PARAM params[])
550 {
551 if (keymgmt->import == NULL)
552 return 0;
553 return keymgmt->import(keydata, selection, params);
554 }
555
evp_keymgmt_import_types(const EVP_KEYMGMT * keymgmt,int selection)556 const OSSL_PARAM *evp_keymgmt_import_types(const EVP_KEYMGMT *keymgmt,
557 int selection)
558 {
559 void *provctx = ossl_provider_ctx(EVP_KEYMGMT_get0_provider(keymgmt));
560
561 if (keymgmt->import_types_ex != NULL)
562 return keymgmt->import_types_ex(provctx, selection);
563 if (keymgmt->import_types == NULL)
564 return NULL;
565 return keymgmt->import_types(selection);
566 }
567
evp_keymgmt_export(const EVP_KEYMGMT * keymgmt,void * keydata,int selection,OSSL_CALLBACK * param_cb,void * cbarg)568 int evp_keymgmt_export(const EVP_KEYMGMT *keymgmt, void *keydata,
569 int selection, OSSL_CALLBACK *param_cb, void *cbarg)
570 {
571 if (keymgmt->export == NULL)
572 return 0;
573 return keymgmt->export(keydata, selection, param_cb, cbarg);
574 }
575
evp_keymgmt_export_types(const EVP_KEYMGMT * keymgmt,int selection)576 const OSSL_PARAM *evp_keymgmt_export_types(const EVP_KEYMGMT *keymgmt,
577 int selection)
578 {
579 void *provctx = ossl_provider_ctx(EVP_KEYMGMT_get0_provider(keymgmt));
580
581 if (keymgmt->export_types_ex != NULL)
582 return keymgmt->export_types_ex(provctx, selection);
583 if (keymgmt->export_types == NULL)
584 return NULL;
585 return keymgmt->export_types(selection);
586 }
587
evp_keymgmt_dup(const EVP_KEYMGMT * keymgmt,const void * keydata_from,int selection)588 void *evp_keymgmt_dup(const EVP_KEYMGMT *keymgmt, const void *keydata_from,
589 int selection)
590 {
591 /* We assume no dup if the implementation doesn't have a function */
592 if (keymgmt->dup == NULL)
593 return NULL;
594 return keymgmt->dup(keydata_from, selection);
595 }
596