VirtualBox

source: vbox/trunk/src/libs/openssl-1.1.1g/crypto/evp/pmeth_lib.c@ 85622

Last change on this file since 85622 was 83916, checked in by vboxsync, 5 years ago

openssl-1.1.1g: Applied and adjusted our OpenSSL changes to 1.1.1g. bugref:9719
File size: 27.1 KB
Line 
1/*
2 * Copyright 2006-2018 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the OpenSSL license (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 "internal/cryptlib.h"
13#include <openssl/engine.h>
14#include <openssl/evp.h>
15#include <openssl/x509v3.h>
16#include "crypto/asn1.h"
17#include "crypto/evp.h"
18#include "internal/numbers.h"
19
20typedef int sk_cmp_fn_type(const char *const *a, const char *const *b);
21
22static STACK_OF(EVP_PKEY_METHOD) *app_pkey_methods = NULL;
23
24/* This array needs to be in order of NIDs */
25static const EVP_PKEY_METHOD *standard_methods[] = {
26#ifndef OPENSSL_NO_RSA
27 &rsa_pkey_meth,
28#endif
29#ifndef OPENSSL_NO_DH
30 &dh_pkey_meth,
31#endif
32#ifndef OPENSSL_NO_DSA
33 &dsa_pkey_meth,
34#endif
35#ifndef OPENSSL_NO_EC
36 &ec_pkey_meth,
37#endif
38 &hmac_pkey_meth,
39#ifndef OPENSSL_NO_CMAC
40 &cmac_pkey_meth,
41#endif
42#ifndef OPENSSL_NO_RSA
43 &rsa_pss_pkey_meth,
44#endif
45#ifndef OPENSSL_NO_DH
46 &dhx_pkey_meth,
47#endif
48#ifndef OPENSSL_NO_SCRYPT
49 &scrypt_pkey_meth,
50#endif
51 &tls1_prf_pkey_meth,
52#ifndef OPENSSL_NO_EC
53 &ecx25519_pkey_meth,
54 &ecx448_pkey_meth,
55#endif
56 &hkdf_pkey_meth,
57#ifndef OPENSSL_NO_POLY1305
58 &poly1305_pkey_meth,
59#endif
60#ifndef OPENSSL_NO_SIPHASH
61 &siphash_pkey_meth,
62#endif
63#ifndef OPENSSL_NO_EC
64 &ed25519_pkey_meth,
65 &ed448_pkey_meth,
66#endif
67#ifndef OPENSSL_NO_SM2
68 &sm2_pkey_meth,
69#endif
70};
71
72DECLARE_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *,
73 pmeth);
74
75static int pmeth_cmp(const EVP_PKEY_METHOD *const *a,
76 const EVP_PKEY_METHOD *const *b)
77{
78 return ((*a)->pkey_id - (*b)->pkey_id);
79}
80
81IMPLEMENT_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *,
82 pmeth);
83
84const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type)
85{
86 EVP_PKEY_METHOD tmp;
87 const EVP_PKEY_METHOD *t = &tmp, **ret;
88 tmp.pkey_id = type;
89 if (app_pkey_methods) {
90 int idx;
91 idx = sk_EVP_PKEY_METHOD_find(app_pkey_methods, &tmp);
92 if (idx >= 0)
93 return sk_EVP_PKEY_METHOD_value(app_pkey_methods, idx);
94 }
95 ret = OBJ_bsearch_pmeth(&t, standard_methods,
96 sizeof(standard_methods) /
97 sizeof(EVP_PKEY_METHOD *));
98 if (!ret || !*ret)
99 return NULL;
100 return *ret;
101}
102
103static EVP_PKEY_CTX *int_ctx_new(EVP_PKEY *pkey, ENGINE *e, int id)
104{
105 EVP_PKEY_CTX *ret;
106 const EVP_PKEY_METHOD *pmeth;
107
108 if (id == -1) {
109 if (pkey == NULL)
110 return 0;
111 id = pkey->type;
112 }
113#ifndef OPENSSL_NO_ENGINE
114 if (e == NULL && pkey != NULL)
115 e = pkey->pmeth_engine != NULL ? pkey->pmeth_engine : pkey->engine;
116 /* Try to find an ENGINE which implements this method */
117 if (e) {
118 if (!ENGINE_init(e)) {
119 EVPerr(EVP_F_INT_CTX_NEW, ERR_R_ENGINE_LIB);
120 return NULL;
121 }
122 } else {
123 e = ENGINE_get_pkey_meth_engine(id);
124 }
125
126 /*
127 * If an ENGINE handled this method look it up. Otherwise use internal
128 * tables.
129 */
130 if (e)
131 pmeth = ENGINE_get_pkey_meth(e, id);
132 else
133#endif
134 pmeth = EVP_PKEY_meth_find(id);
135
136 if (pmeth == NULL) {
137#ifndef OPENSSL_NO_ENGINE
138 ENGINE_finish(e);
139#endif
140 EVPerr(EVP_F_INT_CTX_NEW, EVP_R_UNSUPPORTED_ALGORITHM);
141 return NULL;
142 }
143
144 ret = OPENSSL_zalloc(sizeof(*ret));
145 if (ret == NULL) {
146#ifndef OPENSSL_NO_ENGINE
147 ENGINE_finish(e);
148#endif
149 EVPerr(EVP_F_INT_CTX_NEW, ERR_R_MALLOC_FAILURE);
150 return NULL;
151 }
152 ret->engine = e;
153 ret->pmeth = pmeth;
154 ret->operation = EVP_PKEY_OP_UNDEFINED;
155 ret->pkey = pkey;
156 if (pkey != NULL)
157 EVP_PKEY_up_ref(pkey);
158
159 if (pmeth->init) {
160 if (pmeth->init(ret) <= 0) {
161 ret->pmeth = NULL;
162 EVP_PKEY_CTX_free(ret);
163 return NULL;
164 }
165 }
166
167 return ret;
168}
169
170EVP_PKEY_METHOD *EVP_PKEY_meth_new(int id, int flags)
171{
172 EVP_PKEY_METHOD *pmeth;
173
174 pmeth = OPENSSL_zalloc(sizeof(*pmeth));
175 if (pmeth == NULL) {
176 EVPerr(EVP_F_EVP_PKEY_METH_NEW, ERR_R_MALLOC_FAILURE);
177 return NULL;
178 }
179
180 pmeth->pkey_id = id;
181 pmeth->flags = flags | EVP_PKEY_FLAG_DYNAMIC;
182 return pmeth;
183}
184
185void EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags,
186 const EVP_PKEY_METHOD *meth)
187{
188 if (ppkey_id)
189 *ppkey_id = meth->pkey_id;
190 if (pflags)
191 *pflags = meth->flags;
192}
193
194void EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src)
195{
196
197 dst->init = src->init;
198 dst->copy = src->copy;
199 dst->cleanup = src->cleanup;
200
201 dst->paramgen_init = src->paramgen_init;
202 dst->paramgen = src->paramgen;
203
204 dst->keygen_init = src->keygen_init;
205 dst->keygen = src->keygen;
206
207 dst->sign_init = src->sign_init;
208 dst->sign = src->sign;
209
210 dst->verify_init = src->verify_init;
211 dst->verify = src->verify;
212
213 dst->verify_recover_init = src->verify_recover_init;
214 dst->verify_recover = src->verify_recover;
215
216 dst->signctx_init = src->signctx_init;
217 dst->signctx = src->signctx;
218
219 dst->verifyctx_init = src->verifyctx_init;
220 dst->verifyctx = src->verifyctx;
221
222 dst->encrypt_init = src->encrypt_init;
223 dst->encrypt = src->encrypt;
224
225 dst->decrypt_init = src->decrypt_init;
226 dst->decrypt = src->decrypt;
227
228 dst->derive_init = src->derive_init;
229 dst->derive = src->derive;
230
231 dst->ctrl = src->ctrl;
232 dst->ctrl_str = src->ctrl_str;
233
234 dst->check = src->check;
235}
236
237void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth)
238{
239 if (pmeth && (pmeth->flags & EVP_PKEY_FLAG_DYNAMIC))
240 OPENSSL_free(pmeth);
241}
242
243EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e)
244{
245 return int_ctx_new(pkey, e, -1);
246}
247
248EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e)
249{
250 return int_ctx_new(NULL, e, id);
251}
252
253EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *pctx)
254{
255 EVP_PKEY_CTX *rctx;
256 if (!pctx->pmeth || !pctx->pmeth->copy)
257 return NULL;
258#ifndef OPENSSL_NO_ENGINE
259 /* Make sure it's safe to copy a pkey context using an ENGINE */
260 if (pctx->engine && !ENGINE_init(pctx->engine)) {
261 EVPerr(EVP_F_EVP_PKEY_CTX_DUP, ERR_R_ENGINE_LIB);
262 return 0;
263 }
264#endif
265 rctx = OPENSSL_malloc(sizeof(*rctx));
266 if (rctx == NULL) {
267 EVPerr(EVP_F_EVP_PKEY_CTX_DUP, ERR_R_MALLOC_FAILURE);
268 return NULL;
269 }
270
271 rctx->pmeth = pctx->pmeth;
272#ifndef OPENSSL_NO_ENGINE
273 rctx->engine = pctx->engine;
274#endif
275
276 if (pctx->pkey)
277 EVP_PKEY_up_ref(pctx->pkey);
278
279 rctx->pkey = pctx->pkey;
280
281 if (pctx->peerkey)
282 EVP_PKEY_up_ref(pctx->peerkey);
283
284 rctx->peerkey = pctx->peerkey;
285
286 rctx->data = NULL;
287 rctx->app_data = NULL;
288 rctx->operation = pctx->operation;
289
290 if (pctx->pmeth->copy(rctx, pctx) > 0)
291 return rctx;
292
293 rctx->pmeth = NULL;
294 EVP_PKEY_CTX_free(rctx);
295 return NULL;
296
297}
298
299int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth)
300{
301 if (app_pkey_methods == NULL) {
302 app_pkey_methods = sk_EVP_PKEY_METHOD_new(pmeth_cmp);
303 if (app_pkey_methods == NULL){
304 EVPerr(EVP_F_EVP_PKEY_METH_ADD0, ERR_R_MALLOC_FAILURE);
305 return 0;
306 }
307 }
308 if (!sk_EVP_PKEY_METHOD_push(app_pkey_methods, pmeth)) {
309 EVPerr(EVP_F_EVP_PKEY_METH_ADD0, ERR_R_MALLOC_FAILURE);
310 return 0;
311 }
312 sk_EVP_PKEY_METHOD_sort(app_pkey_methods);
313 return 1;
314}
315
316void evp_app_cleanup_int(void)
317{
318 if (app_pkey_methods != NULL)
319 sk_EVP_PKEY_METHOD_pop_free(app_pkey_methods, EVP_PKEY_meth_free);
320}
321
322int EVP_PKEY_meth_remove(const EVP_PKEY_METHOD *pmeth)
323{
324 const EVP_PKEY_METHOD *ret;
325
326 ret = sk_EVP_PKEY_METHOD_delete_ptr(app_pkey_methods, pmeth);
327
328 return ret == NULL ? 0 : 1;
329}
330
331size_t EVP_PKEY_meth_get_count(void)
332{
333 size_t rv = OSSL_NELEM(standard_methods);
334
335 if (app_pkey_methods)
336 rv += sk_EVP_PKEY_METHOD_num(app_pkey_methods);
337 return rv;
338}
339
340const EVP_PKEY_METHOD *EVP_PKEY_meth_get0(size_t idx)
341{
342 if (idx < OSSL_NELEM(standard_methods))
343 return standard_methods[idx];
344 if (app_pkey_methods == NULL)
345 return NULL;
346 idx -= OSSL_NELEM(standard_methods);
347 if (idx >= (size_t)sk_EVP_PKEY_METHOD_num(app_pkey_methods))
348 return NULL;
349 return sk_EVP_PKEY_METHOD_value(app_pkey_methods, idx);
350}
351
352void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx)
353{
354 if (ctx == NULL)
355 return;
356 if (ctx->pmeth && ctx->pmeth->cleanup)
357 ctx->pmeth->cleanup(ctx);
358 EVP_PKEY_free(ctx->pkey);
359 EVP_PKEY_free(ctx->peerkey);
360#ifndef OPENSSL_NO_ENGINE
361 ENGINE_finish(ctx->engine);
362#endif
363 OPENSSL_free(ctx);
364}
365
366int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype,
367 int cmd, int p1, void *p2)
368{
369 int ret;
370
371 if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl) {
372 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
373 return -2;
374 }
375 if ((keytype != -1) && (ctx->pmeth->pkey_id != keytype))
376 return -1;
377
378 /* Skip the operation checks since this is called in a very early stage */
379 if (ctx->pmeth->digest_custom != NULL)
380 goto doit;
381
382 if (ctx->operation == EVP_PKEY_OP_UNDEFINED) {
383 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_NO_OPERATION_SET);
384 return -1;
385 }
386
387 if ((optype != -1) && !(ctx->operation & optype)) {
388 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_INVALID_OPERATION);
389 return -1;
390 }
391
392 doit:
393 ret = ctx->pmeth->ctrl(ctx, cmd, p1, p2);
394
395 if (ret == -2)
396 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
397
398 return ret;
399}
400
401int EVP_PKEY_CTX_ctrl_uint64(EVP_PKEY_CTX *ctx, int keytype, int optype,
402 int cmd, uint64_t value)
403{
404 return EVP_PKEY_CTX_ctrl(ctx, keytype, optype, cmd, 0, &value);
405}
406
407int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx,
408 const char *name, const char *value)
409{
410 if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl_str) {
411 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR, EVP_R_COMMAND_NOT_SUPPORTED);
412 return -2;
413 }
414 if (strcmp(name, "digest") == 0)
415 return EVP_PKEY_CTX_md(ctx, EVP_PKEY_OP_TYPE_SIG, EVP_PKEY_CTRL_MD,
416 value);
417 return ctx->pmeth->ctrl_str(ctx, name, value);
418}
419
420/* Utility functions to send a string of hex string to a ctrl */
421
422int EVP_PKEY_CTX_str2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *str)
423{
424 size_t len;
425
426 len = strlen(str);
427 if (len > INT_MAX)
428 return -1;
429 return ctx->pmeth->ctrl(ctx, cmd, len, (void *)str);
430}
431
432int EVP_PKEY_CTX_hex2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *hex)
433{
434 unsigned char *bin;
435 long binlen;
436 int rv = -1;
437
438 bin = OPENSSL_hexstr2buf(hex, &binlen);
439 if (bin == NULL)
440 return 0;
441 if (binlen <= INT_MAX)
442 rv = ctx->pmeth->ctrl(ctx, cmd, binlen, bin);
443 OPENSSL_free(bin);
444 return rv;
445}
446
447/* Pass a message digest to a ctrl */
448int EVP_PKEY_CTX_md(EVP_PKEY_CTX *ctx, int optype, int cmd, const char *md)
449{
450 const EVP_MD *m;
451
452 if (md == NULL || (m = EVP_get_digestbyname(md)) == NULL) {
453 EVPerr(EVP_F_EVP_PKEY_CTX_MD, EVP_R_INVALID_DIGEST);
454 return 0;
455 }
456 return EVP_PKEY_CTX_ctrl(ctx, -1, optype, cmd, 0, (void *)m);
457}
458
459int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx)
460{
461 return ctx->operation;
462}
463
464void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen)
465{
466 ctx->keygen_info = dat;
467 ctx->keygen_info_count = datlen;
468}
469
470void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data)
471{
472 ctx->data = data;
473}
474
475void *EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx)
476{
477 return ctx->data;
478}
479
480EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx)
481{
482 return ctx->pkey;
483}
484
485EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx)
486{
487 return ctx->peerkey;
488}
489
490void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data)
491{
492 ctx->app_data = data;
493}
494
495void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx)
496{
497 return ctx->app_data;
498}
499
500void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
501 int (*init) (EVP_PKEY_CTX *ctx))
502{
503 pmeth->init = init;
504}
505
506void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth,
507 int (*copy) (EVP_PKEY_CTX *dst,
508 EVP_PKEY_CTX *src))
509{
510 pmeth->copy = copy;
511}
512
513void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth,
514 void (*cleanup) (EVP_PKEY_CTX *ctx))
515{
516 pmeth->cleanup = cleanup;
517}
518
519void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth,
520 int (*paramgen_init) (EVP_PKEY_CTX *ctx),
521 int (*paramgen) (EVP_PKEY_CTX *ctx,
522 EVP_PKEY *pkey))
523{
524 pmeth->paramgen_init = paramgen_init;
525 pmeth->paramgen = paramgen;
526}
527
528void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth,
529 int (*keygen_init) (EVP_PKEY_CTX *ctx),
530 int (*keygen) (EVP_PKEY_CTX *ctx,
531 EVP_PKEY *pkey))
532{
533 pmeth->keygen_init = keygen_init;
534 pmeth->keygen = keygen;
535}
536
537void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth,
538 int (*sign_init) (EVP_PKEY_CTX *ctx),
539 int (*sign) (EVP_PKEY_CTX *ctx,
540 unsigned char *sig, size_t *siglen,
541 const unsigned char *tbs,
542 size_t tbslen))
543{
544 pmeth->sign_init = sign_init;
545 pmeth->sign = sign;
546}
547
548void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth,
549 int (*verify_init) (EVP_PKEY_CTX *ctx),
550 int (*verify) (EVP_PKEY_CTX *ctx,
551 const unsigned char *sig,
552 size_t siglen,
553 const unsigned char *tbs,
554 size_t tbslen))
555{
556 pmeth->verify_init = verify_init;
557 pmeth->verify = verify;
558}
559
560void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth,
561 int (*verify_recover_init) (EVP_PKEY_CTX
562 *ctx),
563 int (*verify_recover) (EVP_PKEY_CTX
564 *ctx,
565 unsigned char
566 *sig,
567 size_t *siglen,
568 const unsigned
569 char *tbs,
570 size_t tbslen))
571{
572 pmeth->verify_recover_init = verify_recover_init;
573 pmeth->verify_recover = verify_recover;
574}
575
576void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth,
577 int (*signctx_init) (EVP_PKEY_CTX *ctx,
578 EVP_MD_CTX *mctx),
579 int (*signctx) (EVP_PKEY_CTX *ctx,
580 unsigned char *sig,
581 size_t *siglen,
582 EVP_MD_CTX *mctx))
583{
584 pmeth->signctx_init = signctx_init;
585 pmeth->signctx = signctx;
586}
587
588void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth,
589 int (*verifyctx_init) (EVP_PKEY_CTX *ctx,
590 EVP_MD_CTX *mctx),
591 int (*verifyctx) (EVP_PKEY_CTX *ctx,
592 const unsigned char *sig,
593 int siglen,
594 EVP_MD_CTX *mctx))
595{
596 pmeth->verifyctx_init = verifyctx_init;
597 pmeth->verifyctx = verifyctx;
598}
599
600void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth,
601 int (*encrypt_init) (EVP_PKEY_CTX *ctx),
602 int (*encryptfn) (EVP_PKEY_CTX *ctx,
603 unsigned char *out,
604 size_t *outlen,
605 const unsigned char *in,
606 size_t inlen))
607{
608 pmeth->encrypt_init = encrypt_init;
609 pmeth->encrypt = encryptfn;
610}
611
612void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth,
613 int (*decrypt_init) (EVP_PKEY_CTX *ctx),
614 int (*decrypt) (EVP_PKEY_CTX *ctx,
615 unsigned char *out,
616 size_t *outlen,
617 const unsigned char *in,
618 size_t inlen))
619{
620 pmeth->decrypt_init = decrypt_init;
621 pmeth->decrypt = decrypt;
622}
623
624void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth,
625 int (*derive_init) (EVP_PKEY_CTX *ctx),
626 int (*derive) (EVP_PKEY_CTX *ctx,
627 unsigned char *key,
628 size_t *keylen))
629{
630 pmeth->derive_init = derive_init;
631 pmeth->derive = derive;
632}
633
634void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth,
635 int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
636 void *p2),
637 int (*ctrl_str) (EVP_PKEY_CTX *ctx,
638 const char *type,
639 const char *value))
640{
641 pmeth->ctrl = ctrl;
642 pmeth->ctrl_str = ctrl_str;
643}
644
645void EVP_PKEY_meth_set_digestsign(EVP_PKEY_METHOD *pmeth,
646 int (*digestsign) (EVP_MD_CTX *ctx, unsigned char *sig, size_t *siglen,
647 const unsigned char *tbs, size_t tbslen))
648{
649 pmeth->digestsign = digestsign;
650}
651
652void EVP_PKEY_meth_set_digestverify(EVP_PKEY_METHOD *pmeth,
653 int (*digestverify) (EVP_MD_CTX *ctx, const unsigned char *sig,
654 size_t siglen, const unsigned char *tbs,
655 size_t tbslen))
656{
657 pmeth->digestverify = digestverify;
658}
659
660void EVP_PKEY_meth_set_check(EVP_PKEY_METHOD *pmeth,
661 int (*check) (EVP_PKEY *pkey))
662{
663 pmeth->check = check;
664}
665
666void EVP_PKEY_meth_set_public_check(EVP_PKEY_METHOD *pmeth,
667 int (*check) (EVP_PKEY *pkey))
668{
669 pmeth->public_check = check;
670}
671
672void EVP_PKEY_meth_set_param_check(EVP_PKEY_METHOD *pmeth,
673 int (*check) (EVP_PKEY *pkey))
674{
675 pmeth->param_check = check;
676}
677
678void EVP_PKEY_meth_set_digest_custom(EVP_PKEY_METHOD *pmeth,
679 int (*digest_custom) (EVP_PKEY_CTX *ctx,
680 EVP_MD_CTX *mctx))
681{
682 pmeth->digest_custom = digest_custom;
683}
684
685void EVP_PKEY_meth_get_init(const EVP_PKEY_METHOD *pmeth,
686 int (**pinit) (EVP_PKEY_CTX *ctx))
687{
688 *pinit = pmeth->init;
689}
690
691void EVP_PKEY_meth_get_copy(const EVP_PKEY_METHOD *pmeth,
692 int (**pcopy) (EVP_PKEY_CTX *dst,
693 EVP_PKEY_CTX *src))
694{
695 *pcopy = pmeth->copy;
696}
697
698void EVP_PKEY_meth_get_cleanup(const EVP_PKEY_METHOD *pmeth,
699 void (**pcleanup) (EVP_PKEY_CTX *ctx))
700{
701 *pcleanup = pmeth->cleanup;
702}
703
704void EVP_PKEY_meth_get_paramgen(const EVP_PKEY_METHOD *pmeth,
705 int (**pparamgen_init) (EVP_PKEY_CTX *ctx),
706 int (**pparamgen) (EVP_PKEY_CTX *ctx,
707 EVP_PKEY *pkey))
708{
709 if (pparamgen_init)
710 *pparamgen_init = pmeth->paramgen_init;
711 if (pparamgen)
712 *pparamgen = pmeth->paramgen;
713}
714
715void EVP_PKEY_meth_get_keygen(const EVP_PKEY_METHOD *pmeth,
716 int (**pkeygen_init) (EVP_PKEY_CTX *ctx),
717 int (**pkeygen) (EVP_PKEY_CTX *ctx,
718 EVP_PKEY *pkey))
719{
720 if (pkeygen_init)
721 *pkeygen_init = pmeth->keygen_init;
722 if (pkeygen)
723 *pkeygen = pmeth->keygen;
724}
725
726void EVP_PKEY_meth_get_sign(const EVP_PKEY_METHOD *pmeth,
727 int (**psign_init) (EVP_PKEY_CTX *ctx),
728 int (**psign) (EVP_PKEY_CTX *ctx,
729 unsigned char *sig, size_t *siglen,
730 const unsigned char *tbs,
731 size_t tbslen))
732{
733 if (psign_init)
734 *psign_init = pmeth->sign_init;
735 if (psign)
736 *psign = pmeth->sign;
737}
738
739void EVP_PKEY_meth_get_verify(const EVP_PKEY_METHOD *pmeth,
740 int (**pverify_init) (EVP_PKEY_CTX *ctx),
741 int (**pverify) (EVP_PKEY_CTX *ctx,
742 const unsigned char *sig,
743 size_t siglen,
744 const unsigned char *tbs,
745 size_t tbslen))
746{
747 if (pverify_init)
748 *pverify_init = pmeth->verify_init;
749 if (pverify)
750 *pverify = pmeth->verify;
751}
752
753void EVP_PKEY_meth_get_verify_recover(const EVP_PKEY_METHOD *pmeth,
754 int (**pverify_recover_init) (EVP_PKEY_CTX
755 *ctx),
756 int (**pverify_recover) (EVP_PKEY_CTX
757 *ctx,
758 unsigned char
759 *sig,
760 size_t *siglen,
761 const unsigned
762 char *tbs,
763 size_t tbslen))
764{
765 if (pverify_recover_init)
766 *pverify_recover_init = pmeth->verify_recover_init;
767 if (pverify_recover)
768 *pverify_recover = pmeth->verify_recover;
769}
770
771void EVP_PKEY_meth_get_signctx(const EVP_PKEY_METHOD *pmeth,
772 int (**psignctx_init) (EVP_PKEY_CTX *ctx,
773 EVP_MD_CTX *mctx),
774 int (**psignctx) (EVP_PKEY_CTX *ctx,
775 unsigned char *sig,
776 size_t *siglen,
777 EVP_MD_CTX *mctx))
778{
779 if (psignctx_init)
780 *psignctx_init = pmeth->signctx_init;
781 if (psignctx)
782 *psignctx = pmeth->signctx;
783}
784
785void EVP_PKEY_meth_get_verifyctx(const EVP_PKEY_METHOD *pmeth,
786 int (**pverifyctx_init) (EVP_PKEY_CTX *ctx,
787 EVP_MD_CTX *mctx),
788 int (**pverifyctx) (EVP_PKEY_CTX *ctx,
789 const unsigned char *sig,
790 int siglen,
791 EVP_MD_CTX *mctx))
792{
793 if (pverifyctx_init)
794 *pverifyctx_init = pmeth->verifyctx_init;
795 if (pverifyctx)
796 *pverifyctx = pmeth->verifyctx;
797}
798
799void EVP_PKEY_meth_get_encrypt(const EVP_PKEY_METHOD *pmeth,
800 int (**pencrypt_init) (EVP_PKEY_CTX *ctx),
801 int (**pencryptfn) (EVP_PKEY_CTX *ctx,
802 unsigned char *out,
803 size_t *outlen,
804 const unsigned char *in,
805 size_t inlen))
806{
807 if (pencrypt_init)
808 *pencrypt_init = pmeth->encrypt_init;
809 if (pencryptfn)
810 *pencryptfn = pmeth->encrypt;
811}
812
813void EVP_PKEY_meth_get_decrypt(const EVP_PKEY_METHOD *pmeth,
814 int (**pdecrypt_init) (EVP_PKEY_CTX *ctx),
815 int (**pdecrypt) (EVP_PKEY_CTX *ctx,
816 unsigned char *out,
817 size_t *outlen,
818 const unsigned char *in,
819 size_t inlen))
820{
821 if (pdecrypt_init)
822 *pdecrypt_init = pmeth->decrypt_init;
823 if (pdecrypt)
824 *pdecrypt = pmeth->decrypt;
825}
826
827void EVP_PKEY_meth_get_derive(const EVP_PKEY_METHOD *pmeth,
828 int (**pderive_init) (EVP_PKEY_CTX *ctx),
829 int (**pderive) (EVP_PKEY_CTX *ctx,
830 unsigned char *key,
831 size_t *keylen))
832{
833 if (pderive_init)
834 *pderive_init = pmeth->derive_init;
835 if (pderive)
836 *pderive = pmeth->derive;
837}
838
839void EVP_PKEY_meth_get_ctrl(const EVP_PKEY_METHOD *pmeth,
840 int (**pctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
841 void *p2),
842 int (**pctrl_str) (EVP_PKEY_CTX *ctx,
843 const char *type,
844 const char *value))
845{
846 if (pctrl)
847 *pctrl = pmeth->ctrl;
848 if (pctrl_str)
849 *pctrl_str = pmeth->ctrl_str;
850}
851
852void EVP_PKEY_meth_get_digestsign(EVP_PKEY_METHOD *pmeth,
853 int (**digestsign) (EVP_MD_CTX *ctx, unsigned char *sig, size_t *siglen,
854 const unsigned char *tbs, size_t tbslen))
855{
856 if (digestsign)
857 *digestsign = pmeth->digestsign;
858}
859
860void EVP_PKEY_meth_get_digestverify(EVP_PKEY_METHOD *pmeth,
861 int (**digestverify) (EVP_MD_CTX *ctx, const unsigned char *sig,
862 size_t siglen, const unsigned char *tbs,
863 size_t tbslen))
864{
865 if (digestverify)
866 *digestverify = pmeth->digestverify;
867}
868
869void EVP_PKEY_meth_get_check(const EVP_PKEY_METHOD *pmeth,
870 int (**pcheck) (EVP_PKEY *pkey))
871{
872 if (pcheck != NULL)
873 *pcheck = pmeth->check;
874}
875
876void EVP_PKEY_meth_get_public_check(const EVP_PKEY_METHOD *pmeth,
877 int (**pcheck) (EVP_PKEY *pkey))
878{
879 if (pcheck != NULL)
880 *pcheck = pmeth->public_check;
881}
882
883void EVP_PKEY_meth_get_param_check(const EVP_PKEY_METHOD *pmeth,
884 int (**pcheck) (EVP_PKEY *pkey))
885{
886 if (pcheck != NULL)
887 *pcheck = pmeth->param_check;
888}
889
890void EVP_PKEY_meth_get_digest_custom(EVP_PKEY_METHOD *pmeth,
891 int (**pdigest_custom) (EVP_PKEY_CTX *ctx,
892 EVP_MD_CTX *mctx))
893{
894 if (pdigest_custom != NULL)
895 *pdigest_custom = pmeth->digest_custom;
896}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette