ef923fdc5e4468539fdde776cf30fb974cb86cb4
[openssl.git] / crypto / evp / pmeth_lib.c
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 "internal/asn1_int.h"
17 #include "internal/evp_int.h"
18 #include "internal/numbers.h"
19
20 typedef int sk_cmp_fn_type(const char *const *a, const char *const *b);
21
22 static STACK_OF(EVP_PKEY_METHOD) *app_pkey_methods = NULL;
23
24 /* This array needs to be in order of NIDs */
25 static 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
72 DECLARE_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *,
73                            pmeth);
74
75 static 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
81 IMPLEMENT_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *,
82                              pmeth);
83
84 const 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
103 static 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
170 EVP_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
185 void 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
194 void 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
237 void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth)
238 {
239     if (pmeth && (pmeth->flags & EVP_PKEY_FLAG_DYNAMIC))
240         OPENSSL_free(pmeth);
241 }
242
243 EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e)
244 {
245     return int_ctx_new(pkey, e, -1);
246 }
247
248 EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e)
249 {
250     return int_ctx_new(NULL, e, id);
251 }
252
253 EVP_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
299 int 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
316 void 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
322 int 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
331 size_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
340 const 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
352 void 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
366 int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype,
367                       int cmd, int p1, void *p2)
368 {
369     int ret;
370     if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl) {
371         EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
372         return -2;
373     }
374     if ((keytype != -1) && (ctx->pmeth->pkey_id != keytype))
375         return -1;
376
377     if (ctx->operation == EVP_PKEY_OP_UNDEFINED) {
378         EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_NO_OPERATION_SET);
379         return -1;
380     }
381
382     if ((optype != -1) && !(ctx->operation & optype)) {
383         EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_INVALID_OPERATION);
384         return -1;
385     }
386
387     ret = ctx->pmeth->ctrl(ctx, cmd, p1, p2);
388
389     if (ret == -2)
390         EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
391
392     return ret;
393
394 }
395
396 int EVP_PKEY_CTX_ctrl_uint64(EVP_PKEY_CTX *ctx, int keytype, int optype,
397                              int cmd, uint64_t value)
398 {
399     return EVP_PKEY_CTX_ctrl(ctx, keytype, optype, cmd, 0, &value);
400 }
401
402 int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx,
403                           const char *name, const char *value)
404 {
405     if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl_str) {
406         EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR, EVP_R_COMMAND_NOT_SUPPORTED);
407         return -2;
408     }
409     if (strcmp(name, "digest") == 0)
410         return EVP_PKEY_CTX_md(ctx, EVP_PKEY_OP_TYPE_SIG, EVP_PKEY_CTRL_MD,
411                                value);
412     return ctx->pmeth->ctrl_str(ctx, name, value);
413 }
414
415 /* Utility functions to send a string of hex string to a ctrl */
416
417 int EVP_PKEY_CTX_str2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *str)
418 {
419     size_t len;
420
421     len = strlen(str);
422     if (len > INT_MAX)
423         return -1;
424     return ctx->pmeth->ctrl(ctx, cmd, len, (void *)str);
425 }
426
427 int EVP_PKEY_CTX_hex2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *hex)
428 {
429     unsigned char *bin;
430     long binlen;
431     int rv = -1;
432
433     bin = OPENSSL_hexstr2buf(hex, &binlen);
434     if (bin == NULL)
435         return 0;
436     if (binlen <= INT_MAX)
437         rv = ctx->pmeth->ctrl(ctx, cmd, binlen, bin);
438     OPENSSL_free(bin);
439     return rv;
440 }
441
442 /* Pass a message digest to a ctrl */
443 int EVP_PKEY_CTX_md(EVP_PKEY_CTX *ctx, int optype, int cmd, const char *md)
444 {
445     const EVP_MD *m;
446
447     if (md == NULL || (m = EVP_get_digestbyname(md)) == NULL) {
448         EVPerr(EVP_F_EVP_PKEY_CTX_MD, EVP_R_INVALID_DIGEST);
449         return 0;
450     }
451     return EVP_PKEY_CTX_ctrl(ctx, -1, optype, cmd, 0, (void *)m);
452 }
453
454 int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx)
455 {
456     return ctx->operation;
457 }
458
459 void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen)
460 {
461     ctx->keygen_info = dat;
462     ctx->keygen_info_count = datlen;
463 }
464
465 void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data)
466 {
467     ctx->data = data;
468 }
469
470 void *EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx)
471 {
472     return ctx->data;
473 }
474
475 EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx)
476 {
477     return ctx->pkey;
478 }
479
480 EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx)
481 {
482     return ctx->peerkey;
483 }
484
485 void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data)
486 {
487     ctx->app_data = data;
488 }
489
490 void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx)
491 {
492     return ctx->app_data;
493 }
494
495 void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
496                             int (*init) (EVP_PKEY_CTX *ctx))
497 {
498     pmeth->init = init;
499 }
500
501 void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth,
502                             int (*copy) (EVP_PKEY_CTX *dst,
503                                          EVP_PKEY_CTX *src))
504 {
505     pmeth->copy = copy;
506 }
507
508 void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth,
509                                void (*cleanup) (EVP_PKEY_CTX *ctx))
510 {
511     pmeth->cleanup = cleanup;
512 }
513
514 void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth,
515                                 int (*paramgen_init) (EVP_PKEY_CTX *ctx),
516                                 int (*paramgen) (EVP_PKEY_CTX *ctx,
517                                                  EVP_PKEY *pkey))
518 {
519     pmeth->paramgen_init = paramgen_init;
520     pmeth->paramgen = paramgen;
521 }
522
523 void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth,
524                               int (*keygen_init) (EVP_PKEY_CTX *ctx),
525                               int (*keygen) (EVP_PKEY_CTX *ctx,
526                                              EVP_PKEY *pkey))
527 {
528     pmeth->keygen_init = keygen_init;
529     pmeth->keygen = keygen;
530 }
531
532 void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth,
533                             int (*sign_init) (EVP_PKEY_CTX *ctx),
534                             int (*sign) (EVP_PKEY_CTX *ctx,
535                                          unsigned char *sig, size_t *siglen,
536                                          const unsigned char *tbs,
537                                          size_t tbslen))
538 {
539     pmeth->sign_init = sign_init;
540     pmeth->sign = sign;
541 }
542
543 void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth,
544                               int (*verify_init) (EVP_PKEY_CTX *ctx),
545                               int (*verify) (EVP_PKEY_CTX *ctx,
546                                              const unsigned char *sig,
547                                              size_t siglen,
548                                              const unsigned char *tbs,
549                                              size_t tbslen))
550 {
551     pmeth->verify_init = verify_init;
552     pmeth->verify = verify;
553 }
554
555 void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth,
556                                       int (*verify_recover_init) (EVP_PKEY_CTX
557                                                                   *ctx),
558                                       int (*verify_recover) (EVP_PKEY_CTX
559                                                              *ctx,
560                                                              unsigned char
561                                                              *sig,
562                                                              size_t *siglen,
563                                                              const unsigned
564                                                              char *tbs,
565                                                              size_t tbslen))
566 {
567     pmeth->verify_recover_init = verify_recover_init;
568     pmeth->verify_recover = verify_recover;
569 }
570
571 void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth,
572                                int (*signctx_init) (EVP_PKEY_CTX *ctx,
573                                                     EVP_MD_CTX *mctx),
574                                int (*signctx) (EVP_PKEY_CTX *ctx,
575                                                unsigned char *sig,
576                                                size_t *siglen,
577                                                EVP_MD_CTX *mctx))
578 {
579     pmeth->signctx_init = signctx_init;
580     pmeth->signctx = signctx;
581 }
582
583 void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth,
584                                  int (*verifyctx_init) (EVP_PKEY_CTX *ctx,
585                                                         EVP_MD_CTX *mctx),
586                                  int (*verifyctx) (EVP_PKEY_CTX *ctx,
587                                                    const unsigned char *sig,
588                                                    int siglen,
589                                                    EVP_MD_CTX *mctx))
590 {
591     pmeth->verifyctx_init = verifyctx_init;
592     pmeth->verifyctx = verifyctx;
593 }
594
595 void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth,
596                                int (*encrypt_init) (EVP_PKEY_CTX *ctx),
597                                int (*encryptfn) (EVP_PKEY_CTX *ctx,
598                                                  unsigned char *out,
599                                                  size_t *outlen,
600                                                  const unsigned char *in,
601                                                  size_t inlen))
602 {
603     pmeth->encrypt_init = encrypt_init;
604     pmeth->encrypt = encryptfn;
605 }
606
607 void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth,
608                                int (*decrypt_init) (EVP_PKEY_CTX *ctx),
609                                int (*decrypt) (EVP_PKEY_CTX *ctx,
610                                                unsigned char *out,
611                                                size_t *outlen,
612                                                const unsigned char *in,
613                                                size_t inlen))
614 {
615     pmeth->decrypt_init = decrypt_init;
616     pmeth->decrypt = decrypt;
617 }
618
619 void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth,
620                               int (*derive_init) (EVP_PKEY_CTX *ctx),
621                               int (*derive) (EVP_PKEY_CTX *ctx,
622                                              unsigned char *key,
623                                              size_t *keylen))
624 {
625     pmeth->derive_init = derive_init;
626     pmeth->derive = derive;
627 }
628
629 void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth,
630                             int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
631                                          void *p2),
632                             int (*ctrl_str) (EVP_PKEY_CTX *ctx,
633                                              const char *type,
634                                              const char *value))
635 {
636     pmeth->ctrl = ctrl;
637     pmeth->ctrl_str = ctrl_str;
638 }
639
640 void EVP_PKEY_meth_set_check(EVP_PKEY_METHOD *pmeth,
641                              int (*check) (EVP_PKEY *pkey))
642 {
643     pmeth->check = check;
644 }
645
646 void EVP_PKEY_meth_set_public_check(EVP_PKEY_METHOD *pmeth,
647                                     int (*check) (EVP_PKEY *pkey))
648 {
649     pmeth->public_check = check;
650 }
651
652 void EVP_PKEY_meth_set_param_check(EVP_PKEY_METHOD *pmeth,
653                                    int (*check) (EVP_PKEY *pkey))
654 {
655     pmeth->param_check = check;
656 }
657
658 void EVP_PKEY_meth_get_init(const EVP_PKEY_METHOD *pmeth,
659                             int (**pinit) (EVP_PKEY_CTX *ctx))
660 {
661     *pinit = pmeth->init;
662 }
663
664 void EVP_PKEY_meth_get_copy(const EVP_PKEY_METHOD *pmeth,
665                             int (**pcopy) (EVP_PKEY_CTX *dst,
666                                            EVP_PKEY_CTX *src))
667 {
668     *pcopy = pmeth->copy;
669 }
670
671 void EVP_PKEY_meth_get_cleanup(const EVP_PKEY_METHOD *pmeth,
672                                void (**pcleanup) (EVP_PKEY_CTX *ctx))
673 {
674     *pcleanup = pmeth->cleanup;
675 }
676
677 void EVP_PKEY_meth_get_paramgen(const EVP_PKEY_METHOD *pmeth,
678                                 int (**pparamgen_init) (EVP_PKEY_CTX *ctx),
679                                 int (**pparamgen) (EVP_PKEY_CTX *ctx,
680                                                    EVP_PKEY *pkey))
681 {
682     if (pparamgen_init)
683         *pparamgen_init = pmeth->paramgen_init;
684     if (pparamgen)
685         *pparamgen = pmeth->paramgen;
686 }
687
688 void EVP_PKEY_meth_get_keygen(const EVP_PKEY_METHOD *pmeth,
689                               int (**pkeygen_init) (EVP_PKEY_CTX *ctx),
690                               int (**pkeygen) (EVP_PKEY_CTX *ctx,
691                                                EVP_PKEY *pkey))
692 {
693     if (pkeygen_init)
694         *pkeygen_init = pmeth->keygen_init;
695     if (pkeygen)
696         *pkeygen = pmeth->keygen;
697 }
698
699 void EVP_PKEY_meth_get_sign(const EVP_PKEY_METHOD *pmeth,
700                             int (**psign_init) (EVP_PKEY_CTX *ctx),
701                             int (**psign) (EVP_PKEY_CTX *ctx,
702                                            unsigned char *sig, size_t *siglen,
703                                            const unsigned char *tbs,
704                                            size_t tbslen))
705 {
706     if (psign_init)
707         *psign_init = pmeth->sign_init;
708     if (psign)
709         *psign = pmeth->sign;
710 }
711
712 void EVP_PKEY_meth_get_verify(const EVP_PKEY_METHOD *pmeth,
713                               int (**pverify_init) (EVP_PKEY_CTX *ctx),
714                               int (**pverify) (EVP_PKEY_CTX *ctx,
715                                                const unsigned char *sig,
716                                                size_t siglen,
717                                                const unsigned char *tbs,
718                                                size_t tbslen))
719 {
720     if (pverify_init)
721         *pverify_init = pmeth->verify_init;
722     if (pverify)
723         *pverify = pmeth->verify;
724 }
725
726 void EVP_PKEY_meth_get_verify_recover(const EVP_PKEY_METHOD *pmeth,
727                                       int (**pverify_recover_init) (EVP_PKEY_CTX
728                                                                     *ctx),
729                                       int (**pverify_recover) (EVP_PKEY_CTX
730                                                                *ctx,
731                                                                unsigned char
732                                                                *sig,
733                                                                size_t *siglen,
734                                                                const unsigned
735                                                                char *tbs,
736                                                                size_t tbslen))
737 {
738     if (pverify_recover_init)
739         *pverify_recover_init = pmeth->verify_recover_init;
740     if (pverify_recover)
741         *pverify_recover = pmeth->verify_recover;
742 }
743
744 void EVP_PKEY_meth_get_signctx(const EVP_PKEY_METHOD *pmeth,
745                                int (**psignctx_init) (EVP_PKEY_CTX *ctx,
746                                                       EVP_MD_CTX *mctx),
747                                int (**psignctx) (EVP_PKEY_CTX *ctx,
748                                                  unsigned char *sig,
749                                                  size_t *siglen,
750                                                  EVP_MD_CTX *mctx))
751 {
752     if (psignctx_init)
753         *psignctx_init = pmeth->signctx_init;
754     if (psignctx)
755         *psignctx = pmeth->signctx;
756 }
757
758 void EVP_PKEY_meth_get_verifyctx(const EVP_PKEY_METHOD *pmeth,
759                                  int (**pverifyctx_init) (EVP_PKEY_CTX *ctx,
760                                                           EVP_MD_CTX *mctx),
761                                  int (**pverifyctx) (EVP_PKEY_CTX *ctx,
762                                                      const unsigned char *sig,
763                                                      int siglen,
764                                                      EVP_MD_CTX *mctx))
765 {
766     if (pverifyctx_init)
767         *pverifyctx_init = pmeth->verifyctx_init;
768     if (pverifyctx)
769         *pverifyctx = pmeth->verifyctx;
770 }
771
772 void EVP_PKEY_meth_get_encrypt(const EVP_PKEY_METHOD *pmeth,
773                                int (**pencrypt_init) (EVP_PKEY_CTX *ctx),
774                                int (**pencryptfn) (EVP_PKEY_CTX *ctx,
775                                                    unsigned char *out,
776                                                    size_t *outlen,
777                                                    const unsigned char *in,
778                                                    size_t inlen))
779 {
780     if (pencrypt_init)
781         *pencrypt_init = pmeth->encrypt_init;
782     if (pencryptfn)
783         *pencryptfn = pmeth->encrypt;
784 }
785
786 void EVP_PKEY_meth_get_decrypt(const EVP_PKEY_METHOD *pmeth,
787                                int (**pdecrypt_init) (EVP_PKEY_CTX *ctx),
788                                int (**pdecrypt) (EVP_PKEY_CTX *ctx,
789                                                  unsigned char *out,
790                                                  size_t *outlen,
791                                                  const unsigned char *in,
792                                                  size_t inlen))
793 {
794     if (pdecrypt_init)
795         *pdecrypt_init = pmeth->decrypt_init;
796     if (pdecrypt)
797         *pdecrypt = pmeth->decrypt;
798 }
799
800 void EVP_PKEY_meth_get_derive(const EVP_PKEY_METHOD *pmeth,
801                               int (**pderive_init) (EVP_PKEY_CTX *ctx),
802                               int (**pderive) (EVP_PKEY_CTX *ctx,
803                                                unsigned char *key,
804                                                size_t *keylen))
805 {
806     if (pderive_init)
807         *pderive_init = pmeth->derive_init;
808     if (pderive)
809         *pderive = pmeth->derive;
810 }
811
812 void EVP_PKEY_meth_get_ctrl(const EVP_PKEY_METHOD *pmeth,
813                             int (**pctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
814                                            void *p2),
815                             int (**pctrl_str) (EVP_PKEY_CTX *ctx,
816                                                const char *type,
817                                                const char *value))
818 {
819     if (pctrl)
820         *pctrl = pmeth->ctrl;
821     if (pctrl_str)
822         *pctrl_str = pmeth->ctrl_str;
823 }
824
825 void EVP_PKEY_meth_get_check(const EVP_PKEY_METHOD *pmeth,
826                              int (**pcheck) (EVP_PKEY *pkey))
827 {
828     if (*pcheck)
829         *pcheck = pmeth->check;
830 }
831
832 void EVP_PKEY_meth_get_public_check(const EVP_PKEY_METHOD *pmeth,
833                                     int (**pcheck) (EVP_PKEY *pkey))
834 {
835     if (*pcheck)
836         *pcheck = pmeth->public_check;
837 }
838
839 void EVP_PKEY_meth_get_param_check(const EVP_PKEY_METHOD *pmeth,
840                                    int (**pcheck) (EVP_PKEY *pkey))
841 {
842     if (*pcheck)
843         *pcheck = pmeth->param_check;
844 }