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