crypto/evp/pmeth_lib.c

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