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