lib/libcrypto/evp/pmeth_lib.c

   1 /* $OpenBSD: pmeth_lib.c,v 1.13 2017/01/29 17:49:23 beck 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 <stdio.h>
  60 #include <stdlib.h>
  61 #include <string.h>
  62
  63 #include <openssl/opensslconf.h>
  64
  65 #include <openssl/err.h>
  66 #include <openssl/evp.h>
  67 #include <openssl/objects.h>
  68
  69 #ifndef OPENSSL_NO_ENGINE
  70 #include <openssl/engine.h>
  71 #endif
  72
  73 #include "asn1_locl.h"
  74 #include "evp_locl.h"
  75
  76 typedef int sk_cmp_fn_type(const char * const *a, const char * const *b);
  77
  78 DECLARE_STACK_OF(EVP_PKEY_METHOD)
  79 STACK_OF(EVP_PKEY_METHOD) *app_pkey_methods = NULL;
  80
  81 extern const EVP_PKEY_METHOD rsa_pkey_meth, dh_pkey_meth, dsa_pkey_meth;
  82 extern const EVP_PKEY_METHOD ec_pkey_meth, hmac_pkey_meth, cmac_pkey_meth;
  83 extern const EVP_PKEY_METHOD gostimit_pkey_meth, gostr01_pkey_meth;
  84
  85 static const EVP_PKEY_METHOD *standard_methods[] = {
  86 #ifndef OPENSSL_NO_RSA
  87         &rsa_pkey_meth,
  88 #endif
  89 #ifndef OPENSSL_NO_DH
  90         &dh_pkey_meth,
  91 #endif
  92 #ifndef OPENSSL_NO_DSA
  93         &dsa_pkey_meth,
  94 #endif
  95 #ifndef OPENSSL_NO_EC
  96         &ec_pkey_meth,
  97 #endif
  98 #ifndef OPENSSL_NO_GOST
  99         &gostr01_pkey_meth,
 100         &gostimit_pkey_meth,
 101 #endif
 102         &hmac_pkey_meth,
 103         &cmac_pkey_meth,
 104 };
 105
 106 static int pmeth_cmp_BSEARCH_CMP_FN(const void *, const void *);
 107 static int pmeth_cmp(const EVP_PKEY_METHOD * const *, const EVP_PKEY_METHOD * const *);
 108 static const EVP_PKEY_METHOD * *OBJ_bsearch_pmeth(const EVP_PKEY_METHOD * *key, const EVP_PKEY_METHOD * const *base, int num);
 109
 110 static int
 111 pmeth_cmp(const EVP_PKEY_METHOD * const *a, const EVP_PKEY_METHOD * const *b)
 112 {
 113         return ((*a)->pkey_id - (*b)->pkey_id);
 114 }
 115
 116
 117 static int
 118 pmeth_cmp_BSEARCH_CMP_FN(const void *a_, const void *b_)
 119 {
 120         const EVP_PKEY_METHOD * const *a = a_;
 121         const EVP_PKEY_METHOD * const *b = b_;
 122         return pmeth_cmp(a, b);
 123 }
 124
 125 static const EVP_PKEY_METHOD * *
 126 OBJ_bsearch_pmeth(const EVP_PKEY_METHOD * *key, const EVP_PKEY_METHOD * const *base, int num)
 127 {
 128         return (const EVP_PKEY_METHOD * *)OBJ_bsearch_(key, base, num, sizeof(const EVP_PKEY_METHOD *),
 129             pmeth_cmp_BSEARCH_CMP_FN);
 130 }
 131
 132 const EVP_PKEY_METHOD *
 133 EVP_PKEY_meth_find(int type)
 134 {
 135         EVP_PKEY_METHOD tmp;
 136         const EVP_PKEY_METHOD *t = &tmp, **ret;
 137
 138         tmp.pkey_id = type;
 139         if (app_pkey_methods) {
 140                 int idx;
 141                 idx = sk_EVP_PKEY_METHOD_find(app_pkey_methods, &tmp);
 142                 if (idx >= 0)
 143                         return sk_EVP_PKEY_METHOD_value(app_pkey_methods, idx);
 144         }
 145         ret = OBJ_bsearch_pmeth(&t, standard_methods,
 146             sizeof(standard_methods)/sizeof(EVP_PKEY_METHOD *));
 147         if (!ret || !*ret)
 148                 return NULL;
 149         return *ret;
 150 }
 151
 152 static EVP_PKEY_CTX *
 153 int_ctx_new(EVP_PKEY *pkey, ENGINE *e, int id)
 154 {
 155         EVP_PKEY_CTX *ret;
 156         const EVP_PKEY_METHOD *pmeth;
 157
 158         if (id == -1) {
 159                 if (!pkey || !pkey->ameth)
 160                         return NULL;
 161                 id = pkey->ameth->pkey_id;
 162         }
 163 #ifndef OPENSSL_NO_ENGINE
 164         if (pkey && pkey->engine)
 165                 e = pkey->engine;
 166         /* Try to find an ENGINE which implements this method */
 167         if (e) {
 168                 if (!ENGINE_init(e)) {
 169                         EVPerror(ERR_R_ENGINE_LIB);
 170                         return NULL;
 171                 }
 172         } else
 173                 e = ENGINE_get_pkey_meth_engine(id);
 174
 175         /* If an ENGINE handled this method look it up. Othewise
 176          * use internal tables.
 177          */
 178
 179         if (e)
 180                 pmeth = ENGINE_get_pkey_meth(e, id);
 181         else
 182 #endif
 183                 pmeth = EVP_PKEY_meth_find(id);
 184
 185         if (pmeth == NULL) {
 186                 EVPerror(EVP_R_UNSUPPORTED_ALGORITHM);
 187                 return NULL;
 188         }
 189
 190         ret = malloc(sizeof(EVP_PKEY_CTX));
 191         if (!ret) {
 192 #ifndef OPENSSL_NO_ENGINE
 193                 if (e)
 194                         ENGINE_finish(e);
 195 #endif
 196                 EVPerror(ERR_R_MALLOC_FAILURE);
 197                 return NULL;
 198         }
 199         ret->engine = e;
 200         ret->pmeth = pmeth;
 201         ret->operation = EVP_PKEY_OP_UNDEFINED;
 202         ret->pkey = pkey;
 203         ret->peerkey = NULL;
 204         ret->pkey_gencb = 0;
 205         if (pkey)
 206                 CRYPTO_add(&pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
 207         ret->data = NULL;
 208
 209         if (pmeth->init) {
 210                 if (pmeth->init(ret) <= 0) {
 211                         EVP_PKEY_CTX_free(ret);
 212                         return NULL;
 213                 }
 214         }
 215
 216         return ret;
 217 }
 218
 219 EVP_PKEY_METHOD*
 220 EVP_PKEY_meth_new(int id, int flags)
 221 {
 222         EVP_PKEY_METHOD *pmeth;
 223
 224         pmeth = calloc(1, sizeof(EVP_PKEY_METHOD));
 225         if (!pmeth)
 226                 return NULL;
 227
 228         pmeth->pkey_id = id;
 229         pmeth->flags = flags | EVP_PKEY_FLAG_DYNAMIC;
 230
 231         pmeth->init = 0;
 232         pmeth->copy = 0;
 233         pmeth->cleanup = 0;
 234         pmeth->paramgen_init = 0;
 235         pmeth->paramgen = 0;
 236         pmeth->keygen_init = 0;
 237         pmeth->keygen = 0;
 238         pmeth->sign_init = 0;
 239         pmeth->sign = 0;
 240         pmeth->verify_init = 0;
 241         pmeth->verify = 0;
 242         pmeth->verify_recover_init = 0;
 243         pmeth->verify_recover = 0;
 244         pmeth->signctx_init = 0;
 245         pmeth->signctx = 0;
 246         pmeth->verifyctx_init = 0;
 247         pmeth->verifyctx = 0;
 248         pmeth->encrypt_init = 0;
 249         pmeth->encrypt = 0;
 250         pmeth->decrypt_init = 0;
 251         pmeth->decrypt = 0;
 252         pmeth->derive_init = 0;
 253         pmeth->derive = 0;
 254         pmeth->ctrl = 0;
 255         pmeth->ctrl_str = 0;
 256
 257         return pmeth;
 258 }
 259
 260 void
 261 EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags, const EVP_PKEY_METHOD *meth)
 262 {
 263         if (ppkey_id)
 264                 *ppkey_id = meth->pkey_id;
 265         if (pflags)
 266                 *pflags = meth->flags;
 267 }
 268
 269 void
 270 EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src)
 271 {
 272         dst->init = src->init;
 273         dst->copy = src->copy;
 274         dst->cleanup = src->cleanup;
 275
 276         dst->paramgen_init = src->paramgen_init;
 277         dst->paramgen = src->paramgen;
 278
 279         dst->keygen_init = src->keygen_init;
 280         dst->keygen = src->keygen;
 281
 282         dst->sign_init = src->sign_init;
 283         dst->sign = src->sign;
 284
 285         dst->verify_init = src->verify_init;
 286         dst->verify = src->verify;
 287
 288         dst->verify_recover_init = src->verify_recover_init;
 289         dst->verify_recover = src->verify_recover;
 290
 291         dst->signctx_init = src->signctx_init;
 292         dst->signctx = src->signctx;
 293
 294         dst->verifyctx_init = src->verifyctx_init;
 295         dst->verifyctx = src->verifyctx;
 296
 297         dst->encrypt_init = src->encrypt_init;
 298         dst->encrypt = src->encrypt;
 299
 300         dst->decrypt_init = src->decrypt_init;
 301         dst->decrypt = src->decrypt;
 302
 303         dst->derive_init = src->derive_init;
 304         dst->derive = src->derive;
 305
 306         dst->ctrl = src->ctrl;
 307         dst->ctrl_str = src->ctrl_str;
 308 }
 309
 310 void
 311 EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth)
 312 {
 313         if (pmeth && (pmeth->flags & EVP_PKEY_FLAG_DYNAMIC))
 314                 free(pmeth);
 315 }
 316
 317 EVP_PKEY_CTX *
 318 EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e)
 319 {
 320         return int_ctx_new(pkey, e, -1);
 321 }
 322
 323 EVP_PKEY_CTX *
 324 EVP_PKEY_CTX_new_id(int id, ENGINE *e)
 325 {
 326         return int_ctx_new(NULL, e, id);
 327 }
 328
 329 EVP_PKEY_CTX *
 330 EVP_PKEY_CTX_dup(EVP_PKEY_CTX *pctx)
 331 {
 332         EVP_PKEY_CTX *rctx;
 333
 334         if (!pctx->pmeth || !pctx->pmeth->copy)
 335                 return NULL;
 336 #ifndef OPENSSL_NO_ENGINE
 337         /* Make sure it's safe to copy a pkey context using an ENGINE */
 338         if (pctx->engine && !ENGINE_init(pctx->engine)) {
 339                 EVPerror(ERR_R_ENGINE_LIB);
 340                 return 0;
 341         }
 342 #endif
 343         rctx = malloc(sizeof(EVP_PKEY_CTX));
 344         if (!rctx)
 345                 return NULL;
 346
 347         rctx->pmeth = pctx->pmeth;
 348 #ifndef OPENSSL_NO_ENGINE
 349         rctx->engine = pctx->engine;
 350 #endif
 351
 352         if (pctx->pkey)
 353                 CRYPTO_add(&pctx->pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
 354
 355         rctx->pkey = pctx->pkey;
 356
 357         if (pctx->peerkey)
 358                 CRYPTO_add(&pctx->peerkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
 359
 360         rctx->peerkey = pctx->peerkey;
 361
 362         rctx->data = NULL;
 363         rctx->app_data = NULL;
 364         rctx->operation = pctx->operation;
 365
 366         if (pctx->pmeth->copy(rctx, pctx) > 0)
 367                 return rctx;
 368
 369         EVP_PKEY_CTX_free(rctx);
 370         return NULL;
 371 }
 372
 373 int
 374 EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth)
 375 {
 376         if (app_pkey_methods == NULL) {
 377                 app_pkey_methods = sk_EVP_PKEY_METHOD_new(pmeth_cmp);
 378                 if (!app_pkey_methods)
 379                         return 0;
 380         }
 381         if (!sk_EVP_PKEY_METHOD_push(app_pkey_methods, pmeth))
 382                 return 0;
 383         sk_EVP_PKEY_METHOD_sort(app_pkey_methods);
 384         return 1;
 385 }
 386
 387 void
 388 EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx)
 389 {
 390         if (ctx == NULL)
 391                 return;
 392         if (ctx->pmeth && ctx->pmeth->cleanup)
 393                 ctx->pmeth->cleanup(ctx);
 394         EVP_PKEY_free(ctx->pkey);
 395         EVP_PKEY_free(ctx->peerkey);
 396 #ifndef OPENSSL_NO_ENGINE
 397         if (ctx->engine)
 398                 /* The EVP_PKEY_CTX we used belongs to an ENGINE, release the
 399                  * functional reference we held for this reason. */
 400                 ENGINE_finish(ctx->engine);
 401 #endif
 402         free(ctx);
 403 }
 404
 405 int
 406 EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype, int cmd,
 407     int p1, void *p2)
 408 {
 409         int ret;
 410
 411         if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl) {
 412                 EVPerror(EVP_R_COMMAND_NOT_SUPPORTED);
 413                 return -2;
 414         }
 415         if ((keytype != -1) && (ctx->pmeth->pkey_id != keytype))
 416                 return -1;
 417
 418         if (ctx->operation == EVP_PKEY_OP_UNDEFINED) {
 419                 EVPerror(EVP_R_NO_OPERATION_SET);
 420                 return -1;
 421         }
 422
 423         if ((optype != -1) && !(ctx->operation & optype)) {
 424                 EVPerror(EVP_R_INVALID_OPERATION);
 425                 return -1;
 426         }
 427
 428         ret = ctx->pmeth->ctrl(ctx, cmd, p1, p2);
 429
 430         if (ret == -2)
 431                 EVPerror(EVP_R_COMMAND_NOT_SUPPORTED);
 432
 433         return ret;
 434
 435 }
 436
 437 int
 438 EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, const char *name, const char *value)
 439 {
 440         if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl_str) {
 441                 EVPerror(EVP_R_COMMAND_NOT_SUPPORTED);
 442                 return -2;
 443         }
 444         if (!strcmp(name, "digest")) {
 445                 const EVP_MD *md;
 446                 if (!value || !(md = EVP_get_digestbyname(value))) {
 447                         EVPerror(EVP_R_INVALID_DIGEST);
 448                         return 0;
 449                 }
 450                 return EVP_PKEY_CTX_set_signature_md(ctx, md);
 451         }
 452         return ctx->pmeth->ctrl_str(ctx, name, value);
 453 }
 454
 455 int
 456 EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx)
 457 {
 458         return ctx->operation;
 459 }
 460
 461 void
 462 EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen)
 463 {
 464         ctx->keygen_info = dat;
 465         ctx->keygen_info_count = datlen;
 466 }
 467
 468 void
 469 EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data)
 470 {
 471         ctx->data = data;
 472 }
 473
 474 void *
 475 EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx)
 476 {
 477         return ctx->data;
 478 }
 479
 480 EVP_PKEY *
 481 EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx)
 482 {
 483         return ctx->pkey;
 484 }
 485
 486 EVP_PKEY *
 487 EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx)
 488 {
 489         return ctx->peerkey;
 490 }
 491
 492 void
 493 EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data)
 494 {
 495         ctx->app_data = data;
 496 }
 497
 498 void *
 499 EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx)
 500 {
 501         return ctx->app_data;
 502 }
 503
 504 void
 505 EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
 506     int (*init)(EVP_PKEY_CTX *ctx))
 507 {
 508         pmeth->init = init;
 509 }
 510
 511 void
 512 EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth,
 513     int (*copy)(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src))
 514 {
 515         pmeth->copy = copy;
 516 }
 517
 518 void
 519 EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth,
 520     void (*cleanup)(EVP_PKEY_CTX *ctx))
 521 {
 522         pmeth->cleanup = cleanup;
 523 }
 524
 525 void
 526 EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth,
 527     int (*paramgen_init)(EVP_PKEY_CTX *ctx),
 528     int (*paramgen)(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey))
 529 {
 530         pmeth->paramgen_init = paramgen_init;
 531         pmeth->paramgen = paramgen;
 532 }
 533
 534 void
 535 EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth,
 536     int (*keygen_init)(EVP_PKEY_CTX *ctx),
 537     int (*keygen)(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey))
 538 {
 539         pmeth->keygen_init = keygen_init;
 540         pmeth->keygen = keygen;
 541 }
 542
 543 void
 544 EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth,
 545     int (*sign_init)(EVP_PKEY_CTX *ctx),
 546     int (*sign)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
 547     const unsigned char *tbs, size_t tbslen))
 548 {
 549         pmeth->sign_init = sign_init;
 550         pmeth->sign = sign;
 551 }
 552
 553 void
 554 EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth,
 555     int (*verify_init)(EVP_PKEY_CTX *ctx),
 556     int (*verify)(EVP_PKEY_CTX *ctx, const unsigned char *sig, size_t siglen,
 557     const unsigned char *tbs, size_t tbslen))
 558 {
 559         pmeth->verify_init = verify_init;
 560         pmeth->verify = verify;
 561 }
 562
 563 void
 564 EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth,
 565     int (*verify_recover_init)(EVP_PKEY_CTX *ctx),
 566     int (*verify_recover)(EVP_PKEY_CTX *ctx,
 567     unsigned char *sig, size_t *siglen,
 568     const unsigned char *tbs, size_t tbslen))
 569 {
 570         pmeth->verify_recover_init = verify_recover_init;
 571         pmeth->verify_recover = verify_recover;
 572 }
 573
 574 void
 575 EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth,
 576     int (*signctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx),
 577     int (*signctx)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
 578     EVP_MD_CTX *mctx))
 579 {
 580         pmeth->signctx_init = signctx_init;
 581         pmeth->signctx = signctx;
 582 }
 583
 584 void
 585 EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth,
 586     int (*verifyctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx),
 587     int (*verifyctx)(EVP_PKEY_CTX *ctx, const unsigned char *sig, int siglen,
 588     EVP_MD_CTX *mctx))
 589 {
 590         pmeth->verifyctx_init = verifyctx_init;
 591         pmeth->verifyctx = verifyctx;
 592 }
 593
 594 void
 595 EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth,
 596     int (*encrypt_init)(EVP_PKEY_CTX *ctx),
 597     int (*encryptfn)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
 598     const unsigned char *in, size_t inlen))
 599 {
 600         pmeth->encrypt_init = encrypt_init;
 601         pmeth->encrypt = encryptfn;
 602 }
 603
 604 void
 605 EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth,
 606     int (*decrypt_init)(EVP_PKEY_CTX *ctx),
 607     int (*decrypt)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
 608     const unsigned char *in, size_t inlen))
 609 {
 610         pmeth->decrypt_init = decrypt_init;
 611         pmeth->decrypt = decrypt;
 612 }
 613
 614 void
 615 EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth,
 616     int (*derive_init)(EVP_PKEY_CTX *ctx),
 617     int (*derive)(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen))
 618 {
 619         pmeth->derive_init = derive_init;
 620         pmeth->derive = derive;
 621 }
 622
 623 void
 624 EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth,
 625     int (*ctrl)(EVP_PKEY_CTX *ctx, int type, int p1, void *p2),
 626     int (*ctrl_str)(EVP_PKEY_CTX *ctx, const char *type, const char *value))
 627 {
 628         pmeth->ctrl = ctrl;
 629         pmeth->ctrl_str = ctrl_str;
 630 }