crypto/libressl/crypto/evp/pmeth_lib.c

   1 /* $OpenBSD: pmeth_lib.c,v 1.22 2022/05/05 08:51:21 tb Exp $ */
   2 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
   3  * project 2006.
   4  */
   5 /* ====================================================================
   6  * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in
  17  *    the documentation and/or other materials provided with the
  18  *    distribution.
  19  *
  20  * 3. All advertising materials mentioning features or use of this
  21  *    software must display the following acknowledgment:
  22  *    "This product includes software developed by the OpenSSL Project
  23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  24  *
  25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26  *    endorse or promote products derived from this software without
  27  *    prior written permission. For written permission, please contact
  28  *    licensing@OpenSSL.org.
  29  *
  30  * 5. Products derived from this software may not be called "OpenSSL"
  31  *    nor may "OpenSSL" appear in their names without prior written
  32  *    permission of the OpenSSL Project.
  33  *
  34  * 6. Redistributions of any form whatsoever must retain the following
  35  *    acknowledgment:
  36  *    "This product includes software developed by the OpenSSL Project
  37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  38  *
  39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50  * OF THE POSSIBILITY OF SUCH DAMAGE.
  51  * ====================================================================
  52  *
  53  * This product includes cryptographic software written by Eric Young
  54  * (eay@cryptsoft.com).  This product includes software written by Tim
  55  * Hudson (tjh@cryptsoft.com).
  56  *
  57  */
  58
  59 #include <limits.h>
  60 #include <stdio.h>
  61 #include <stdlib.h>
  62 #include <string.h>
  63
  64 #include <openssl/opensslconf.h>
  65
  66 #include <openssl/err.h>
  67 #include <openssl/evp.h>
  68 #include <openssl/objects.h>
  69 #include <openssl/x509v3.h>
  70
  71 #ifndef OPENSSL_NO_ENGINE
  72 #include <openssl/engine.h>
  73 #endif
  74
  75 #include "asn1_locl.h"
  76 #include "evp_locl.h"
  77
  78 typedef int sk_cmp_fn_type(const char * const *a, const char * const *b);
  79
  80 DECLARE_STACK_OF(EVP_PKEY_METHOD)
  81 STACK_OF(EVP_PKEY_METHOD) *app_pkey_methods = NULL;
  82
  83 extern const EVP_PKEY_METHOD rsa_pkey_meth, rsa_pss_pkey_meth;
  84 extern const EVP_PKEY_METHOD dh_pkey_meth, dsa_pkey_meth;
  85 extern const EVP_PKEY_METHOD ec_pkey_meth, hmac_pkey_meth, cmac_pkey_meth;
  86 extern const EVP_PKEY_METHOD gostimit_pkey_meth, gostr01_pkey_meth;
  87 extern const EVP_PKEY_METHOD hkdf_pkey_meth;
  88
  89 static const EVP_PKEY_METHOD *standard_methods[] = {
  90 #ifndef OPENSSL_NO_RSA
  91         &rsa_pkey_meth,
  92 #endif
  93 #ifndef OPENSSL_NO_DH
  94         &dh_pkey_meth,
  95 #endif
  96 #ifndef OPENSSL_NO_DSA
  97         &dsa_pkey_meth,
  98 #endif
  99 #ifndef OPENSSL_NO_EC
 100         &ec_pkey_meth,
 101 #endif
 102 #ifndef OPENSSL_NO_GOST
 103         &gostr01_pkey_meth,
 104         &gostimit_pkey_meth,
 105 #endif
 106         &hmac_pkey_meth,
 107         &cmac_pkey_meth,
 108 #ifndef OPENSSL_NO_RSA
 109         &rsa_pss_pkey_meth,
 110 #endif
 111         &hkdf_pkey_meth,
 112 };
 113
 114 static int pmeth_cmp_BSEARCH_CMP_FN(const void *, const void *);
 115 static int pmeth_cmp(const EVP_PKEY_METHOD * const *, const EVP_PKEY_METHOD * const *);
 116 static const EVP_PKEY_METHOD * *OBJ_bsearch_pmeth(const EVP_PKEY_METHOD * *key, const EVP_PKEY_METHOD * const *base, int num);
 117
 118 static int
 119 pmeth_cmp(const EVP_PKEY_METHOD * const *a, const EVP_PKEY_METHOD * const *b)
 120 {
 121         return ((*a)->pkey_id - (*b)->pkey_id);
 122 }
 123
 124
 125 static int
 126 pmeth_cmp_BSEARCH_CMP_FN(const void *a_, const void *b_)
 127 {
 128         const EVP_PKEY_METHOD * const *a = a_;
 129         const EVP_PKEY_METHOD * const *b = b_;
 130         return pmeth_cmp(a, b);
 131 }
 132
 133 static const EVP_PKEY_METHOD * *
 134 OBJ_bsearch_pmeth(const EVP_PKEY_METHOD * *key, const EVP_PKEY_METHOD * const *base, int num)
 135 {
 136         return (const EVP_PKEY_METHOD * *)OBJ_bsearch_(key, base, num, sizeof(const EVP_PKEY_METHOD *),
 137             pmeth_cmp_BSEARCH_CMP_FN);
 138 }
 139
 140 const EVP_PKEY_METHOD *
 141 EVP_PKEY_meth_find(int type)
 142 {
 143         EVP_PKEY_METHOD tmp;
 144         const EVP_PKEY_METHOD *t = &tmp, **ret;
 145
 146         tmp.pkey_id = type;
 147         if (app_pkey_methods) {
 148                 int idx;
 149                 idx = sk_EVP_PKEY_METHOD_find(app_pkey_methods, &tmp);
 150                 if (idx >= 0)
 151                         return sk_EVP_PKEY_METHOD_value(app_pkey_methods, idx);
 152         }
 153         ret = OBJ_bsearch_pmeth(&t, standard_methods,
 154             sizeof(standard_methods)/sizeof(EVP_PKEY_METHOD *));
 155         if (!ret || !*ret)
 156                 return NULL;
 157         return *ret;
 158 }
 159
 160 static EVP_PKEY_CTX *
 161 int_ctx_new(EVP_PKEY *pkey, ENGINE *e, int id)
 162 {
 163         EVP_PKEY_CTX *ret;
 164         const EVP_PKEY_METHOD *pmeth;
 165
 166         if (id == -1) {
 167                 if (!pkey || !pkey->ameth)
 168                         return NULL;
 169                 id = pkey->ameth->pkey_id;
 170         }
 171 #ifndef OPENSSL_NO_ENGINE
 172         if (pkey && pkey->engine)
 173                 e = pkey->engine;
 174         /* Try to find an ENGINE which implements this method */
 175         if (e) {
 176                 if (!ENGINE_init(e)) {
 177                         EVPerror(ERR_R_ENGINE_LIB);
 178                         return NULL;
 179                 }
 180         } else
 181                 e = ENGINE_get_pkey_meth_engine(id);
 182
 183         /* If an ENGINE handled this method look it up. Othewise
 184          * use internal tables.
 185          */
 186
 187         if (e)
 188                 pmeth = ENGINE_get_pkey_meth(e, id);
 189         else
 190 #endif
 191                 pmeth = EVP_PKEY_meth_find(id);
 192
 193         if (pmeth == NULL) {
 194                 EVPerror(EVP_R_UNSUPPORTED_ALGORITHM);
 195                 return NULL;
 196         }
 197
 198         ret = malloc(sizeof(EVP_PKEY_CTX));
 199         if (ret == NULL) {
 200 #ifndef OPENSSL_NO_ENGINE
 201                 ENGINE_finish(e);
 202 #endif
 203                 EVPerror(ERR_R_MALLOC_FAILURE);
 204                 return NULL;
 205         }
 206         ret->engine = e;
 207         ret->pmeth = pmeth;
 208         ret->operation = EVP_PKEY_OP_UNDEFINED;
 209         ret->pkey = pkey;
 210         ret->peerkey = NULL;
 211         ret->pkey_gencb = 0;
 212         if (pkey)
 213                 CRYPTO_add(&pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
 214         ret->data = NULL;
 215
 216         if (pmeth->init) {
 217                 if (pmeth->init(ret) <= 0) {
 218                         EVP_PKEY_CTX_free(ret);
 219                         return NULL;
 220                 }
 221         }
 222
 223         return ret;
 224 }
 225
 226 EVP_PKEY_METHOD*
 227 EVP_PKEY_meth_new(int id, int flags)
 228 {
 229         EVP_PKEY_METHOD *pmeth;
 230
 231         if ((pmeth = calloc(1, sizeof(EVP_PKEY_METHOD))) == NULL)
 232                 return NULL;
 233
 234         pmeth->pkey_id = id;
 235         pmeth->flags = flags | EVP_PKEY_FLAG_DYNAMIC;
 236
 237         return pmeth;
 238 }
 239
 240 void
 241 EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags, const EVP_PKEY_METHOD *meth)
 242 {
 243         if (ppkey_id)
 244                 *ppkey_id = meth->pkey_id;
 245         if (pflags)
 246                 *pflags = meth->flags;
 247 }
 248
 249 void
 250 EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src)
 251 {
 252         EVP_PKEY_METHOD preserve;
 253
 254         preserve.pkey_id = dst->pkey_id;
 255         preserve.flags = dst->flags;
 256
 257         *dst = *src;
 258
 259         dst->pkey_id = preserve.pkey_id;
 260         dst->flags = preserve.flags;
 261 }
 262
 263 void
 264 EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth)
 265 {
 266         if (pmeth && (pmeth->flags & EVP_PKEY_FLAG_DYNAMIC))
 267                 free(pmeth);
 268 }
 269
 270 EVP_PKEY_CTX *
 271 EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e)
 272 {
 273         return int_ctx_new(pkey, e, -1);
 274 }
 275
 276 EVP_PKEY_CTX *
 277 EVP_PKEY_CTX_new_id(int id, ENGINE *e)
 278 {
 279         return int_ctx_new(NULL, e, id);
 280 }
 281
 282 EVP_PKEY_CTX *
 283 EVP_PKEY_CTX_dup(EVP_PKEY_CTX *pctx)
 284 {
 285         EVP_PKEY_CTX *rctx;
 286
 287         if (!pctx->pmeth || !pctx->pmeth->copy)
 288                 return NULL;
 289 #ifndef OPENSSL_NO_ENGINE
 290         /* Make sure it's safe to copy a pkey context using an ENGINE */
 291         if (pctx->engine && !ENGINE_init(pctx->engine)) {
 292                 EVPerror(ERR_R_ENGINE_LIB);
 293                 return 0;
 294         }
 295 #endif
 296         rctx = malloc(sizeof(EVP_PKEY_CTX));
 297         if (!rctx)
 298                 return NULL;
 299
 300         rctx->pmeth = pctx->pmeth;
 301 #ifndef OPENSSL_NO_ENGINE
 302         rctx->engine = pctx->engine;
 303 #endif
 304
 305         if (pctx->pkey)
 306                 CRYPTO_add(&pctx->pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
 307
 308         rctx->pkey = pctx->pkey;
 309
 310         if (pctx->peerkey)
 311                 CRYPTO_add(&pctx->peerkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
 312
 313         rctx->peerkey = pctx->peerkey;
 314
 315         rctx->data = NULL;
 316         rctx->app_data = NULL;
 317         rctx->operation = pctx->operation;
 318
 319         if (pctx->pmeth->copy(rctx, pctx) > 0)
 320                 return rctx;
 321
 322         EVP_PKEY_CTX_free(rctx);
 323         return NULL;
 324 }
 325
 326 int
 327 EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth)
 328 {
 329         if (app_pkey_methods == NULL) {
 330                 app_pkey_methods = sk_EVP_PKEY_METHOD_new(pmeth_cmp);
 331                 if (!app_pkey_methods)
 332                         return 0;
 333         }
 334         if (!sk_EVP_PKEY_METHOD_push(app_pkey_methods, pmeth))
 335                 return 0;
 336         sk_EVP_PKEY_METHOD_sort(app_pkey_methods);
 337         return 1;
 338 }
 339
 340 void
 341 EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx)
 342 {
 343         if (ctx == NULL)
 344                 return;
 345         if (ctx->pmeth && ctx->pmeth->cleanup)
 346                 ctx->pmeth->cleanup(ctx);
 347         EVP_PKEY_free(ctx->pkey);
 348         EVP_PKEY_free(ctx->peerkey);
 349 #ifndef OPENSSL_NO_ENGINE
 350         ENGINE_finish(ctx->engine);
 351 #endif
 352         free(ctx);
 353 }
 354
 355 int
 356 EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype, int cmd,
 357     int p1, void *p2)
 358 {
 359         int ret;
 360
 361         if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl) {
 362                 EVPerror(EVP_R_COMMAND_NOT_SUPPORTED);
 363                 return -2;
 364         }
 365         if ((keytype != -1) && (ctx->pmeth->pkey_id != keytype))
 366                 return -1;
 367
 368         if (ctx->operation == EVP_PKEY_OP_UNDEFINED) {
 369                 EVPerror(EVP_R_NO_OPERATION_SET);
 370                 return -1;
 371         }
 372
 373         if ((optype != -1) && !(ctx->operation & optype)) {
 374                 EVPerror(EVP_R_INVALID_OPERATION);
 375                 return -1;
 376         }
 377
 378         ret = ctx->pmeth->ctrl(ctx, cmd, p1, p2);
 379
 380         if (ret == -2)
 381                 EVPerror(EVP_R_COMMAND_NOT_SUPPORTED);
 382
 383         return ret;
 384
 385 }
 386
 387 int
 388 EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, const char *name, const char *value)
 389 {
 390         if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl_str) {
 391                 EVPerror(EVP_R_COMMAND_NOT_SUPPORTED);
 392                 return -2;
 393         }
 394         if (!strcmp(name, "digest")) {
 395                 return EVP_PKEY_CTX_md(ctx, EVP_PKEY_OP_TYPE_SIG,
 396                     EVP_PKEY_CTRL_MD, value);
 397         }
 398         return ctx->pmeth->ctrl_str(ctx, name, value);
 399 }
 400
 401 int
 402 EVP_PKEY_CTX_str2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *str)
 403 {
 404         size_t len;
 405
 406         if ((len = strlen(str)) > INT_MAX)
 407                 return -1;
 408
 409         return ctx->pmeth->ctrl(ctx, cmd, len, (void *)str);
 410 }
 411
 412 int
 413 EVP_PKEY_CTX_hex2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *hexstr)
 414 {
 415         unsigned char *hex = NULL;
 416         long length;
 417         int ret = 0;
 418
 419         if ((hex = string_to_hex(hexstr, &length)) == NULL)
 420                 goto err;
 421         if (length < 0 || length > INT_MAX) {
 422                 ret = -1;
 423                 goto err;
 424         }
 425
 426         ret = ctx->pmeth->ctrl(ctx, cmd, length, hex);
 427
 428  err:
 429         free(hex);
 430         return ret;
 431 }
 432
 433 int
 434 EVP_PKEY_CTX_md(EVP_PKEY_CTX *ctx, int optype, int cmd, const char *md_name)
 435 {
 436         const EVP_MD *md;
 437
 438         if ((md = EVP_get_digestbyname(md_name)) == NULL) {
 439                 EVPerror(EVP_R_INVALID_DIGEST);
 440                 return 0;
 441         }
 442         return EVP_PKEY_CTX_ctrl(ctx, -1, optype, cmd, 0, (void *)md);
 443 }
 444
 445 int
 446 EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx)
 447 {
 448         return ctx->operation;
 449 }
 450
 451 void
 452 EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen)
 453 {
 454         ctx->keygen_info = dat;
 455         ctx->keygen_info_count = datlen;
 456 }
 457
 458 void
 459 EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data)
 460 {
 461         ctx->data = data;
 462 }
 463
 464 void *
 465 EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx)
 466 {
 467         return ctx->data;
 468 }
 469
 470 EVP_PKEY *
 471 EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx)
 472 {
 473         return ctx->pkey;
 474 }
 475
 476 EVP_PKEY *
 477 EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx)
 478 {
 479         return ctx->peerkey;
 480 }
 481
 482 void
 483 EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data)
 484 {
 485         ctx->app_data = data;
 486 }
 487
 488 void *
 489 EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx)
 490 {
 491         return ctx->app_data;
 492 }
 493
 494 void
 495 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
 502 EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth,
 503     int (*copy)(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src))
 504 {
 505         pmeth->copy = copy;
 506 }
 507
 508 void
 509 EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth,
 510     void (*cleanup)(EVP_PKEY_CTX *ctx))
 511 {
 512         pmeth->cleanup = cleanup;
 513 }
 514
 515 void
 516 EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth,
 517     int (*paramgen_init)(EVP_PKEY_CTX *ctx),
 518     int (*paramgen)(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey))
 519 {
 520         pmeth->paramgen_init = paramgen_init;
 521         pmeth->paramgen = paramgen;
 522 }
 523
 524 void
 525 EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth,
 526     int (*keygen_init)(EVP_PKEY_CTX *ctx),
 527     int (*keygen)(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey))
 528 {
 529         pmeth->keygen_init = keygen_init;
 530         pmeth->keygen = keygen;
 531 }
 532
 533 void
 534 EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth,
 535     int (*sign_init)(EVP_PKEY_CTX *ctx),
 536     int (*sign)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
 537     const unsigned char *tbs, size_t tbslen))
 538 {
 539         pmeth->sign_init = sign_init;
 540         pmeth->sign = sign;
 541 }
 542
 543 void
 544 EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth,
 545     int (*verify_init)(EVP_PKEY_CTX *ctx),
 546     int (*verify)(EVP_PKEY_CTX *ctx, const unsigned char *sig, size_t siglen,
 547     const unsigned char *tbs, size_t tbslen))
 548 {
 549         pmeth->verify_init = verify_init;
 550         pmeth->verify = verify;
 551 }
 552
 553 void
 554 EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth,
 555     int (*verify_recover_init)(EVP_PKEY_CTX *ctx),
 556     int (*verify_recover)(EVP_PKEY_CTX *ctx,
 557     unsigned char *sig, size_t *siglen,
 558     const unsigned char *tbs, size_t tbslen))
 559 {
 560         pmeth->verify_recover_init = verify_recover_init;
 561         pmeth->verify_recover = verify_recover;
 562 }
 563
 564 void
 565 EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth,
 566     int (*signctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx),
 567     int (*signctx)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
 568     EVP_MD_CTX *mctx))
 569 {
 570         pmeth->signctx_init = signctx_init;
 571         pmeth->signctx = signctx;
 572 }
 573
 574 void
 575 EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth,
 576     int (*verifyctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx),
 577     int (*verifyctx)(EVP_PKEY_CTX *ctx, const unsigned char *sig, int siglen,
 578     EVP_MD_CTX *mctx))
 579 {
 580         pmeth->verifyctx_init = verifyctx_init;
 581         pmeth->verifyctx = verifyctx;
 582 }
 583
 584 void
 585 EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth,
 586     int (*encrypt_init)(EVP_PKEY_CTX *ctx),
 587     int (*encryptfn)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
 588     const unsigned char *in, size_t inlen))
 589 {
 590         pmeth->encrypt_init = encrypt_init;
 591         pmeth->encrypt = encryptfn;
 592 }
 593
 594 void
 595 EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth,
 596     int (*decrypt_init)(EVP_PKEY_CTX *ctx),
 597     int (*decrypt)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
 598     const unsigned char *in, size_t inlen))
 599 {
 600         pmeth->decrypt_init = decrypt_init;
 601         pmeth->decrypt = decrypt;
 602 }
 603
 604 void
 605 EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth,
 606     int (*derive_init)(EVP_PKEY_CTX *ctx),
 607     int (*derive)(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen))
 608 {
 609         pmeth->derive_init = derive_init;
 610         pmeth->derive = derive;
 611 }
 612
 613 void
 614 EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth,
 615     int (*ctrl)(EVP_PKEY_CTX *ctx, int type, int p1, void *p2),
 616     int (*ctrl_str)(EVP_PKEY_CTX *ctx, const char *type, const char *value))
 617 {
 618         pmeth->ctrl = ctrl;
 619         pmeth->ctrl_str = ctrl_str;
 620 }
 621
 622 void
 623 EVP_PKEY_meth_set_check(EVP_PKEY_METHOD *pmeth, int (*check)(EVP_PKEY *pkey))
 624 {
 625         pmeth->check = check;
 626 }
 627
 628 void
 629 EVP_PKEY_meth_set_public_check(EVP_PKEY_METHOD *pmeth,
 630     int (*public_check)(EVP_PKEY *pkey))
 631 {
 632         pmeth->public_check = public_check;
 633 }
 634
 635 void
 636 EVP_PKEY_meth_set_param_check(EVP_PKEY_METHOD *pmeth,
 637     int (*param_check)(EVP_PKEY *pkey))
 638 {
 639         pmeth->param_check = param_check;
 640 }