/src/openssl/crypto/evp/signature.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * Copyright 2006-2016 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 <stdio.h> |
11 | | #include <stdlib.h> |
12 | | #include <openssl/objects.h> |
13 | | #include <openssl/evp.h> |
14 | | #include "internal/cryptlib.h" |
15 | | #include "crypto/evp.h" |
16 | | #include "internal/provider.h" |
17 | | #include "evp_local.h" |
18 | | |
19 | | static EVP_SIGNATURE *evp_signature_new(OSSL_PROVIDER *prov) |
20 | 0 | { |
21 | 0 | EVP_SIGNATURE *signature = OPENSSL_zalloc(sizeof(EVP_SIGNATURE)); |
22 | |
|
23 | 0 | if (signature == NULL) { |
24 | 0 | ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE); |
25 | 0 | return NULL; |
26 | 0 | } |
27 | | |
28 | 0 | signature->lock = CRYPTO_THREAD_lock_new(); |
29 | 0 | if (signature->lock == NULL) { |
30 | 0 | ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE); |
31 | 0 | OPENSSL_free(signature); |
32 | 0 | return NULL; |
33 | 0 | } |
34 | 0 | signature->prov = prov; |
35 | 0 | ossl_provider_up_ref(prov); |
36 | 0 | signature->refcnt = 1; |
37 | |
|
38 | 0 | return signature; |
39 | 0 | } |
40 | | |
41 | | static void *evp_signature_from_dispatch(int name_id, |
42 | | const OSSL_DISPATCH *fns, |
43 | | OSSL_PROVIDER *prov) |
44 | 0 | { |
45 | 0 | EVP_SIGNATURE *signature = NULL; |
46 | 0 | int ctxfncnt = 0, signfncnt = 0, verifyfncnt = 0, verifyrecfncnt = 0; |
47 | 0 | int digsignfncnt = 0, digverifyfncnt = 0; |
48 | 0 | int gparamfncnt = 0, sparamfncnt = 0, gmdparamfncnt = 0, smdparamfncnt = 0; |
49 | |
|
50 | 0 | if ((signature = evp_signature_new(prov)) == NULL) { |
51 | 0 | ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE); |
52 | 0 | goto err; |
53 | 0 | } |
54 | | |
55 | 0 | signature->name_id = name_id; |
56 | |
|
57 | 0 | for (; fns->function_id != 0; fns++) { |
58 | 0 | switch (fns->function_id) { |
59 | 0 | case OSSL_FUNC_SIGNATURE_NEWCTX: |
60 | 0 | if (signature->newctx != NULL) |
61 | 0 | break; |
62 | 0 | signature->newctx = OSSL_get_OP_signature_newctx(fns); |
63 | 0 | ctxfncnt++; |
64 | 0 | break; |
65 | 0 | case OSSL_FUNC_SIGNATURE_SIGN_INIT: |
66 | 0 | if (signature->sign_init != NULL) |
67 | 0 | break; |
68 | 0 | signature->sign_init = OSSL_get_OP_signature_sign_init(fns); |
69 | 0 | signfncnt++; |
70 | 0 | break; |
71 | 0 | case OSSL_FUNC_SIGNATURE_SIGN: |
72 | 0 | if (signature->sign != NULL) |
73 | 0 | break; |
74 | 0 | signature->sign = OSSL_get_OP_signature_sign(fns); |
75 | 0 | signfncnt++; |
76 | 0 | break; |
77 | 0 | case OSSL_FUNC_SIGNATURE_VERIFY_INIT: |
78 | 0 | if (signature->verify_init != NULL) |
79 | 0 | break; |
80 | 0 | signature->verify_init = OSSL_get_OP_signature_verify_init(fns); |
81 | 0 | verifyfncnt++; |
82 | 0 | break; |
83 | 0 | case OSSL_FUNC_SIGNATURE_VERIFY: |
84 | 0 | if (signature->verify != NULL) |
85 | 0 | break; |
86 | 0 | signature->verify = OSSL_get_OP_signature_verify(fns); |
87 | 0 | verifyfncnt++; |
88 | 0 | break; |
89 | 0 | case OSSL_FUNC_SIGNATURE_VERIFY_RECOVER_INIT: |
90 | 0 | if (signature->verify_recover_init != NULL) |
91 | 0 | break; |
92 | 0 | signature->verify_recover_init |
93 | 0 | = OSSL_get_OP_signature_verify_recover_init(fns); |
94 | 0 | verifyrecfncnt++; |
95 | 0 | break; |
96 | 0 | case OSSL_FUNC_SIGNATURE_VERIFY_RECOVER: |
97 | 0 | if (signature->verify_recover != NULL) |
98 | 0 | break; |
99 | 0 | signature->verify_recover |
100 | 0 | = OSSL_get_OP_signature_verify_recover(fns); |
101 | 0 | verifyrecfncnt++; |
102 | 0 | break; |
103 | 0 | case OSSL_FUNC_SIGNATURE_DIGEST_SIGN_INIT: |
104 | 0 | if (signature->digest_sign_init != NULL) |
105 | 0 | break; |
106 | 0 | signature->digest_sign_init |
107 | 0 | = OSSL_get_OP_signature_digest_sign_init(fns); |
108 | 0 | digsignfncnt++; |
109 | 0 | break; |
110 | 0 | case OSSL_FUNC_SIGNATURE_DIGEST_SIGN_UPDATE: |
111 | 0 | if (signature->digest_sign_update != NULL) |
112 | 0 | break; |
113 | 0 | signature->digest_sign_update |
114 | 0 | = OSSL_get_OP_signature_digest_sign_update(fns); |
115 | 0 | digsignfncnt++; |
116 | 0 | break; |
117 | 0 | case OSSL_FUNC_SIGNATURE_DIGEST_SIGN_FINAL: |
118 | 0 | if (signature->digest_sign_final != NULL) |
119 | 0 | break; |
120 | 0 | signature->digest_sign_final |
121 | 0 | = OSSL_get_OP_signature_digest_sign_final(fns); |
122 | 0 | digsignfncnt++; |
123 | 0 | break; |
124 | 0 | case OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_INIT: |
125 | 0 | if (signature->digest_verify_init != NULL) |
126 | 0 | break; |
127 | 0 | signature->digest_verify_init |
128 | 0 | = OSSL_get_OP_signature_digest_verify_init(fns); |
129 | 0 | digverifyfncnt++; |
130 | 0 | break; |
131 | 0 | case OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_UPDATE: |
132 | 0 | if (signature->digest_verify_update != NULL) |
133 | 0 | break; |
134 | 0 | signature->digest_verify_update |
135 | 0 | = OSSL_get_OP_signature_digest_verify_update(fns); |
136 | 0 | digverifyfncnt++; |
137 | 0 | break; |
138 | 0 | case OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_FINAL: |
139 | 0 | if (signature->digest_verify_final != NULL) |
140 | 0 | break; |
141 | 0 | signature->digest_verify_final |
142 | 0 | = OSSL_get_OP_signature_digest_verify_final(fns); |
143 | 0 | digverifyfncnt++; |
144 | 0 | break; |
145 | 0 | case OSSL_FUNC_SIGNATURE_FREECTX: |
146 | 0 | if (signature->freectx != NULL) |
147 | 0 | break; |
148 | 0 | signature->freectx = OSSL_get_OP_signature_freectx(fns); |
149 | 0 | ctxfncnt++; |
150 | 0 | break; |
151 | 0 | case OSSL_FUNC_SIGNATURE_DUPCTX: |
152 | 0 | if (signature->dupctx != NULL) |
153 | 0 | break; |
154 | 0 | signature->dupctx = OSSL_get_OP_signature_dupctx(fns); |
155 | 0 | break; |
156 | 0 | case OSSL_FUNC_SIGNATURE_GET_CTX_PARAMS: |
157 | 0 | if (signature->get_ctx_params != NULL) |
158 | 0 | break; |
159 | 0 | signature->get_ctx_params |
160 | 0 | = OSSL_get_OP_signature_get_ctx_params(fns); |
161 | 0 | gparamfncnt++; |
162 | 0 | break; |
163 | 0 | case OSSL_FUNC_SIGNATURE_GETTABLE_CTX_PARAMS: |
164 | 0 | if (signature->gettable_ctx_params != NULL) |
165 | 0 | break; |
166 | 0 | signature->gettable_ctx_params |
167 | 0 | = OSSL_get_OP_signature_gettable_ctx_params(fns); |
168 | 0 | gparamfncnt++; |
169 | 0 | break; |
170 | 0 | case OSSL_FUNC_SIGNATURE_SET_CTX_PARAMS: |
171 | 0 | if (signature->set_ctx_params != NULL) |
172 | 0 | break; |
173 | 0 | signature->set_ctx_params |
174 | 0 | = OSSL_get_OP_signature_set_ctx_params(fns); |
175 | 0 | sparamfncnt++; |
176 | 0 | break; |
177 | 0 | case OSSL_FUNC_SIGNATURE_SETTABLE_CTX_PARAMS: |
178 | 0 | if (signature->settable_ctx_params != NULL) |
179 | 0 | break; |
180 | 0 | signature->settable_ctx_params |
181 | 0 | = OSSL_get_OP_signature_settable_ctx_params(fns); |
182 | 0 | sparamfncnt++; |
183 | 0 | break; |
184 | 0 | case OSSL_FUNC_SIGNATURE_GET_CTX_MD_PARAMS: |
185 | 0 | if (signature->get_ctx_md_params != NULL) |
186 | 0 | break; |
187 | 0 | signature->get_ctx_md_params |
188 | 0 | = OSSL_get_OP_signature_get_ctx_md_params(fns); |
189 | 0 | gmdparamfncnt++; |
190 | 0 | break; |
191 | 0 | case OSSL_FUNC_SIGNATURE_GETTABLE_CTX_MD_PARAMS: |
192 | 0 | if (signature->gettable_ctx_md_params != NULL) |
193 | 0 | break; |
194 | 0 | signature->gettable_ctx_md_params |
195 | 0 | = OSSL_get_OP_signature_gettable_ctx_md_params(fns); |
196 | 0 | gmdparamfncnt++; |
197 | 0 | break; |
198 | 0 | case OSSL_FUNC_SIGNATURE_SET_CTX_MD_PARAMS: |
199 | 0 | if (signature->set_ctx_md_params != NULL) |
200 | 0 | break; |
201 | 0 | signature->set_ctx_md_params |
202 | 0 | = OSSL_get_OP_signature_set_ctx_md_params(fns); |
203 | 0 | smdparamfncnt++; |
204 | 0 | break; |
205 | 0 | case OSSL_FUNC_SIGNATURE_SETTABLE_CTX_MD_PARAMS: |
206 | 0 | if (signature->settable_ctx_md_params != NULL) |
207 | 0 | break; |
208 | 0 | signature->settable_ctx_md_params |
209 | 0 | = OSSL_get_OP_signature_settable_ctx_md_params(fns); |
210 | 0 | smdparamfncnt++; |
211 | 0 | break; |
212 | 0 | } |
213 | 0 | } |
214 | 0 | if (ctxfncnt != 2 |
215 | 0 | || (signfncnt == 0 |
216 | 0 | && verifyfncnt == 0 |
217 | 0 | && verifyrecfncnt == 0 |
218 | 0 | && digsignfncnt == 0 |
219 | 0 | && digverifyfncnt == 0) |
220 | 0 | || (signfncnt != 0 && signfncnt != 2) |
221 | 0 | || (verifyfncnt != 0 && verifyfncnt != 2) |
222 | 0 | || (verifyrecfncnt != 0 && verifyrecfncnt != 2) |
223 | 0 | || (digsignfncnt != 0 && digsignfncnt != 3) |
224 | 0 | || (digverifyfncnt != 0 && digverifyfncnt != 3) |
225 | 0 | || (gparamfncnt != 0 && gparamfncnt != 2) |
226 | 0 | || (sparamfncnt != 0 && sparamfncnt != 2) |
227 | 0 | || (gmdparamfncnt != 0 && gmdparamfncnt != 2) |
228 | 0 | || (smdparamfncnt != 0 && smdparamfncnt != 2)) { |
229 | | /* |
230 | | * In order to be a consistent set of functions we must have at least |
231 | | * a set of context functions (newctx and freectx) as well as a set of |
232 | | * "signature" functions: |
233 | | * (sign_init, sign) or |
234 | | * (verify_init verify) or |
235 | | * (verify_recover_init, verify_recover) or |
236 | | * (digest_sign_init, digest_sign_update, digest_sign_final) or |
237 | | * (digest_verify_init, digest_verify_update, digest_verify_final). |
238 | | * |
239 | | * set_ctx_params and settable_ctx_params are optional, but if one of |
240 | | * them is present then the other one must also be present. The same |
241 | | * applies to get_ctx_params and gettable_ctx_params. The same rules |
242 | | * apply to the "md_params" functions. The dupctx function is optional. |
243 | | */ |
244 | 0 | ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_PROVIDER_FUNCTIONS); |
245 | 0 | goto err; |
246 | 0 | } |
247 | | |
248 | 0 | return signature; |
249 | 0 | err: |
250 | 0 | EVP_SIGNATURE_free(signature); |
251 | 0 | return NULL; |
252 | 0 | } |
253 | | |
254 | | void EVP_SIGNATURE_free(EVP_SIGNATURE *signature) |
255 | 0 | { |
256 | 0 | if (signature != NULL) { |
257 | 0 | int i; |
258 | |
|
259 | 0 | CRYPTO_DOWN_REF(&signature->refcnt, &i, signature->lock); |
260 | 0 | if (i > 0) |
261 | 0 | return; |
262 | 0 | ossl_provider_free(signature->prov); |
263 | 0 | CRYPTO_THREAD_lock_free(signature->lock); |
264 | 0 | OPENSSL_free(signature); |
265 | 0 | } |
266 | 0 | } |
267 | | |
268 | | int EVP_SIGNATURE_up_ref(EVP_SIGNATURE *signature) |
269 | 0 | { |
270 | 0 | int ref = 0; |
271 | |
|
272 | 0 | CRYPTO_UP_REF(&signature->refcnt, &ref, signature->lock); |
273 | 0 | return 1; |
274 | 0 | } |
275 | | |
276 | | OSSL_PROVIDER *EVP_SIGNATURE_provider(const EVP_SIGNATURE *signature) |
277 | 0 | { |
278 | 0 | return signature->prov; |
279 | 0 | } |
280 | | |
281 | | EVP_SIGNATURE *EVP_SIGNATURE_fetch(OPENSSL_CTX *ctx, const char *algorithm, |
282 | | const char *properties) |
283 | 0 | { |
284 | 0 | return evp_generic_fetch(ctx, OSSL_OP_SIGNATURE, algorithm, properties, |
285 | 0 | evp_signature_from_dispatch, |
286 | 0 | (int (*)(void *))EVP_SIGNATURE_up_ref, |
287 | 0 | (void (*)(void *))EVP_SIGNATURE_free); |
288 | 0 | } |
289 | | |
290 | | int EVP_SIGNATURE_is_a(const EVP_SIGNATURE *signature, const char *name) |
291 | 0 | { |
292 | 0 | return evp_is_a(signature->prov, signature->name_id, NULL, name); |
293 | 0 | } |
294 | | |
295 | | int EVP_SIGNATURE_number(const EVP_SIGNATURE *signature) |
296 | 0 | { |
297 | 0 | return signature->name_id; |
298 | 0 | } |
299 | | |
300 | | void EVP_SIGNATURE_do_all_provided(OPENSSL_CTX *libctx, |
301 | | void (*fn)(EVP_SIGNATURE *signature, |
302 | | void *arg), |
303 | | void *arg) |
304 | 0 | { |
305 | 0 | evp_generic_do_all(libctx, OSSL_OP_SIGNATURE, |
306 | 0 | (void (*)(void *, void *))fn, arg, |
307 | 0 | evp_signature_from_dispatch, |
308 | 0 | (void (*)(void *))EVP_SIGNATURE_free); |
309 | 0 | } |
310 | | |
311 | | |
312 | | void EVP_SIGNATURE_names_do_all(const EVP_SIGNATURE *signature, |
313 | | void (*fn)(const char *name, void *data), |
314 | | void *data) |
315 | 0 | { |
316 | 0 | if (signature->prov != NULL) |
317 | 0 | evp_names_do_all(signature->prov, signature->name_id, fn, data); |
318 | 0 | } |
319 | | |
320 | | static int evp_pkey_signature_init(EVP_PKEY_CTX *ctx, int operation) |
321 | 0 | { |
322 | 0 | int ret = 0; |
323 | 0 | void *provkey = NULL; |
324 | 0 | EVP_SIGNATURE *signature = NULL; |
325 | 0 | EVP_KEYMGMT *tmp_keymgmt = NULL; |
326 | 0 | const char *supported_sig = NULL; |
327 | |
|
328 | 0 | if (ctx == NULL) { |
329 | 0 | EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE); |
330 | 0 | return -2; |
331 | 0 | } |
332 | | |
333 | 0 | evp_pkey_ctx_free_old_ops(ctx); |
334 | 0 | ctx->operation = operation; |
335 | | |
336 | | /* |
337 | | * TODO when we stop falling back to legacy, this and the ERR_pop_to_mark() |
338 | | * calls can be removed. |
339 | | */ |
340 | 0 | ERR_set_mark(); |
341 | |
|
342 | 0 | if (ctx->keytype == NULL) |
343 | 0 | goto legacy; |
344 | | |
345 | | /* Ensure that the key is provided. If not, go legacy */ |
346 | 0 | tmp_keymgmt = ctx->keymgmt; |
347 | 0 | provkey = evp_pkey_make_provided(ctx->pkey, ctx->libctx, |
348 | 0 | &tmp_keymgmt, ctx->propquery); |
349 | 0 | if (provkey == NULL) |
350 | 0 | goto legacy; |
351 | 0 | if (!EVP_KEYMGMT_up_ref(tmp_keymgmt)) { |
352 | 0 | ERR_clear_last_mark(); |
353 | 0 | ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR); |
354 | 0 | goto err; |
355 | 0 | } |
356 | 0 | EVP_KEYMGMT_free(ctx->keymgmt); |
357 | 0 | ctx->keymgmt = tmp_keymgmt; |
358 | |
|
359 | 0 | if (ctx->keymgmt->query_operation_name != NULL) |
360 | 0 | supported_sig = ctx->keymgmt->query_operation_name(OSSL_OP_SIGNATURE); |
361 | | |
362 | | /* |
363 | | * If we didn't get a supported sig, assume there is one with the |
364 | | * same name as the key type. |
365 | | */ |
366 | 0 | if (supported_sig == NULL) |
367 | 0 | supported_sig = ctx->keytype; |
368 | | |
369 | | /* |
370 | | * Because we cleared out old ops, we shouldn't need to worry about |
371 | | * checking if signature is already there. |
372 | | */ |
373 | 0 | signature = |
374 | 0 | EVP_SIGNATURE_fetch(ctx->libctx, supported_sig, ctx->propquery); |
375 | |
|
376 | 0 | if (signature == NULL |
377 | 0 | || (EVP_KEYMGMT_provider(ctx->keymgmt) |
378 | 0 | != EVP_SIGNATURE_provider(signature))) { |
379 | | /* |
380 | | * We don't need to free ctx->keymgmt here, as it's not necessarily |
381 | | * tied to this operation. It will be freed by EVP_PKEY_CTX_free(). |
382 | | */ |
383 | 0 | EVP_SIGNATURE_free(signature); |
384 | 0 | goto legacy; |
385 | 0 | } |
386 | | |
387 | | /* |
388 | | * TODO remove this when legacy is gone |
389 | | * If we don't have the full support we need with provided methods, |
390 | | * let's go see if legacy does. |
391 | | */ |
392 | 0 | ERR_pop_to_mark(); |
393 | | |
394 | | /* No more legacy from here down to legacy: */ |
395 | |
|
396 | 0 | ctx->op.sig.signature = signature; |
397 | 0 | ctx->op.sig.sigprovctx = signature->newctx(ossl_provider_ctx(signature->prov)); |
398 | 0 | if (ctx->op.sig.sigprovctx == NULL) { |
399 | | /* The provider key can stay in the cache */ |
400 | 0 | EVPerr(0, EVP_R_INITIALIZATION_ERROR); |
401 | 0 | goto err; |
402 | 0 | } |
403 | | |
404 | 0 | switch (operation) { |
405 | 0 | case EVP_PKEY_OP_SIGN: |
406 | 0 | if (signature->sign_init == NULL) { |
407 | 0 | EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE); |
408 | 0 | ret = -2; |
409 | 0 | goto err; |
410 | 0 | } |
411 | 0 | ret = signature->sign_init(ctx->op.sig.sigprovctx, provkey); |
412 | 0 | break; |
413 | 0 | case EVP_PKEY_OP_VERIFY: |
414 | 0 | if (signature->verify_init == NULL) { |
415 | 0 | EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE); |
416 | 0 | ret = -2; |
417 | 0 | goto err; |
418 | 0 | } |
419 | 0 | ret = signature->verify_init(ctx->op.sig.sigprovctx, provkey); |
420 | 0 | break; |
421 | 0 | case EVP_PKEY_OP_VERIFYRECOVER: |
422 | 0 | if (signature->verify_recover_init == NULL) { |
423 | 0 | EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE); |
424 | 0 | ret = -2; |
425 | 0 | goto err; |
426 | 0 | } |
427 | 0 | ret = signature->verify_recover_init(ctx->op.sig.sigprovctx, provkey); |
428 | 0 | break; |
429 | 0 | default: |
430 | 0 | EVPerr(0, EVP_R_INITIALIZATION_ERROR); |
431 | 0 | goto err; |
432 | 0 | } |
433 | | |
434 | 0 | if (ret <= 0) { |
435 | 0 | signature->freectx(ctx->op.sig.sigprovctx); |
436 | 0 | ctx->op.sig.sigprovctx = NULL; |
437 | 0 | goto err; |
438 | 0 | } |
439 | 0 | return 1; |
440 | | |
441 | 0 | legacy: |
442 | | /* |
443 | | * TODO remove this when legacy is gone |
444 | | * If we don't have the full support we need with provided methods, |
445 | | * let's go see if legacy does. |
446 | | */ |
447 | 0 | ERR_pop_to_mark(); |
448 | |
|
449 | 0 | if (ctx->pmeth == NULL |
450 | 0 | || (operation == EVP_PKEY_OP_SIGN && ctx->pmeth->sign == NULL) |
451 | 0 | || (operation == EVP_PKEY_OP_VERIFY && ctx->pmeth->verify == NULL) |
452 | 0 | || (operation == EVP_PKEY_OP_VERIFYRECOVER |
453 | 0 | && ctx->pmeth->verify_recover == NULL)) { |
454 | 0 | EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE); |
455 | 0 | return -2; |
456 | 0 | } |
457 | | |
458 | 0 | switch (operation) { |
459 | 0 | case EVP_PKEY_OP_SIGN: |
460 | 0 | if (ctx->pmeth->sign_init == NULL) |
461 | 0 | return 1; |
462 | 0 | ret = ctx->pmeth->sign_init(ctx); |
463 | 0 | break; |
464 | 0 | case EVP_PKEY_OP_VERIFY: |
465 | 0 | if (ctx->pmeth->verify_init == NULL) |
466 | 0 | return 1; |
467 | 0 | ret = ctx->pmeth->verify_init(ctx); |
468 | 0 | break; |
469 | 0 | case EVP_PKEY_OP_VERIFYRECOVER: |
470 | 0 | if (ctx->pmeth->verify_recover_init == NULL) |
471 | 0 | return 1; |
472 | 0 | ret = ctx->pmeth->verify_recover_init(ctx); |
473 | 0 | break; |
474 | 0 | default: |
475 | 0 | EVPerr(0, EVP_R_INITIALIZATION_ERROR); |
476 | 0 | goto err; |
477 | 0 | } |
478 | 0 | if (ret <= 0) |
479 | 0 | goto err; |
480 | 0 | return ret; |
481 | | |
482 | 0 | err: |
483 | 0 | ctx->operation = EVP_PKEY_OP_UNDEFINED; |
484 | 0 | return ret; |
485 | 0 | } |
486 | | |
487 | | int EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx) |
488 | 0 | { |
489 | 0 | return evp_pkey_signature_init(ctx, EVP_PKEY_OP_SIGN); |
490 | 0 | } |
491 | | |
492 | | int EVP_PKEY_sign(EVP_PKEY_CTX *ctx, |
493 | | unsigned char *sig, size_t *siglen, |
494 | | const unsigned char *tbs, size_t tbslen) |
495 | 0 | { |
496 | 0 | int ret; |
497 | |
|
498 | 0 | if (ctx == NULL) { |
499 | 0 | EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE); |
500 | 0 | return -2; |
501 | 0 | } |
502 | | |
503 | 0 | if (ctx->operation != EVP_PKEY_OP_SIGN) { |
504 | 0 | EVPerr(0, EVP_R_OPERATON_NOT_INITIALIZED); |
505 | 0 | return -1; |
506 | 0 | } |
507 | | |
508 | 0 | if (ctx->op.sig.sigprovctx == NULL) |
509 | 0 | goto legacy; |
510 | | |
511 | 0 | ret = ctx->op.sig.signature->sign(ctx->op.sig.sigprovctx, sig, siglen, |
512 | 0 | SIZE_MAX, tbs, tbslen); |
513 | |
|
514 | 0 | return ret; |
515 | 0 | legacy: |
516 | |
|
517 | 0 | if (ctx->pmeth == NULL || ctx->pmeth->sign == NULL) { |
518 | 0 | EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE); |
519 | 0 | return -2; |
520 | 0 | } |
521 | | |
522 | 0 | M_check_autoarg(ctx, sig, siglen, EVP_F_EVP_PKEY_SIGN) |
523 | 0 | return ctx->pmeth->sign(ctx, sig, siglen, tbs, tbslen); |
524 | 0 | } |
525 | | |
526 | | int EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx) |
527 | 0 | { |
528 | 0 | return evp_pkey_signature_init(ctx, EVP_PKEY_OP_VERIFY); |
529 | 0 | } |
530 | | |
531 | | int EVP_PKEY_verify(EVP_PKEY_CTX *ctx, |
532 | | const unsigned char *sig, size_t siglen, |
533 | | const unsigned char *tbs, size_t tbslen) |
534 | 0 | { |
535 | 0 | int ret; |
536 | |
|
537 | 0 | if (ctx == NULL) { |
538 | 0 | EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE); |
539 | 0 | return -2; |
540 | 0 | } |
541 | | |
542 | 0 | if (ctx->operation != EVP_PKEY_OP_VERIFY) { |
543 | 0 | EVPerr(0, EVP_R_OPERATON_NOT_INITIALIZED); |
544 | 0 | return -1; |
545 | 0 | } |
546 | | |
547 | 0 | if (ctx->op.sig.sigprovctx == NULL) |
548 | 0 | goto legacy; |
549 | | |
550 | 0 | ret = ctx->op.sig.signature->verify(ctx->op.sig.sigprovctx, sig, siglen, |
551 | 0 | tbs, tbslen); |
552 | |
|
553 | 0 | return ret; |
554 | 0 | legacy: |
555 | 0 | if (ctx->pmeth == NULL || ctx->pmeth->verify == NULL) { |
556 | 0 | EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE); |
557 | 0 | return -2; |
558 | 0 | } |
559 | | |
560 | 0 | return ctx->pmeth->verify(ctx, sig, siglen, tbs, tbslen); |
561 | 0 | } |
562 | | |
563 | | int EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx) |
564 | 0 | { |
565 | 0 | return evp_pkey_signature_init(ctx, EVP_PKEY_OP_VERIFYRECOVER); |
566 | 0 | } |
567 | | |
568 | | int EVP_PKEY_verify_recover(EVP_PKEY_CTX *ctx, |
569 | | unsigned char *rout, size_t *routlen, |
570 | | const unsigned char *sig, size_t siglen) |
571 | 0 | { |
572 | 0 | int ret; |
573 | |
|
574 | 0 | if (ctx == NULL) { |
575 | 0 | EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE); |
576 | 0 | return -2; |
577 | 0 | } |
578 | | |
579 | 0 | if (ctx->operation != EVP_PKEY_OP_VERIFYRECOVER) { |
580 | 0 | EVPerr(0, EVP_R_OPERATON_NOT_INITIALIZED); |
581 | 0 | return -1; |
582 | 0 | } |
583 | | |
584 | 0 | if (ctx->op.sig.sigprovctx == NULL) |
585 | 0 | goto legacy; |
586 | | |
587 | 0 | ret = ctx->op.sig.signature->verify_recover(ctx->op.sig.sigprovctx, rout, |
588 | 0 | routlen, |
589 | 0 | (rout == NULL ? 0 : *routlen), |
590 | 0 | sig, siglen); |
591 | 0 | return ret; |
592 | 0 | legacy: |
593 | 0 | if (ctx->pmeth == NULL || ctx->pmeth->verify_recover == NULL) { |
594 | 0 | EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE); |
595 | 0 | return -2; |
596 | 0 | } |
597 | 0 | M_check_autoarg(ctx, rout, routlen, EVP_F_EVP_PKEY_VERIFY_RECOVER) |
598 | 0 | return ctx->pmeth->verify_recover(ctx, rout, routlen, sig, siglen); |
599 | 0 | } |