1 /* 2 * Copyright 2006-2018 The OpenSSL Project Authors. All Rights Reserved. 3 * 4 * Licensed under the OpenSSL license (the "License"). You may not use 5 * this file except in compliance with the License. You can obtain a copy 6 * in the file LICENSE in the source distribution or at 7 * https://www.openssl.org/source/license.html 8 */ 9 10 #include <stdio.h> 11 #include <stdlib.h> 12 #include "internal/cryptlib.h" 13 #include <openssl/engine.h> 14 #include <openssl/evp.h> 15 #include <openssl/x509v3.h> 16 #include "crypto/asn1.h" 17 #include "crypto/evp.h" 18 #include "internal/numbers.h" 19 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 371 if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl) { 372 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED); 373 return -2; 374 } 375 if ((keytype != -1) && (ctx->pmeth->pkey_id != keytype)) 376 return -1; 377 378 /* Skip the operation checks since this is called in a very early stage */ 379 if (ctx->pmeth->digest_custom != NULL) 380 goto doit; 381 382 if (ctx->operation == EVP_PKEY_OP_UNDEFINED) { 383 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_NO_OPERATION_SET); 384 return -1; 385 } 386 387 if ((optype != -1) && !(ctx->operation & optype)) { 388 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_INVALID_OPERATION); 389 return -1; 390 } 391 392 doit: 393 ret = ctx->pmeth->ctrl(ctx, cmd, p1, p2); 394 395 if (ret == -2) 396 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED); 397 398 return ret; 399 } 400 401 int EVP_PKEY_CTX_ctrl_uint64(EVP_PKEY_CTX *ctx, int keytype, int optype, 402 int cmd, uint64_t value) 403 { 404 return EVP_PKEY_CTX_ctrl(ctx, keytype, optype, cmd, 0, &value); 405 } 406 407 int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, 408 const char *name, const char *value) 409 { 410 if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl_str) { 411 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR, EVP_R_COMMAND_NOT_SUPPORTED); 412 return -2; 413 } 414 if (strcmp(name, "digest") == 0) 415 return EVP_PKEY_CTX_md(ctx, EVP_PKEY_OP_TYPE_SIG, EVP_PKEY_CTRL_MD, 416 value); 417 return ctx->pmeth->ctrl_str(ctx, name, value); 418 } 419 420 /* Utility functions to send a string of hex string to a ctrl */ 421 422 int EVP_PKEY_CTX_str2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *str) 423 { 424 size_t len; 425 426 len = strlen(str); 427 if (len > INT_MAX) 428 return -1; 429 return ctx->pmeth->ctrl(ctx, cmd, len, (void *)str); 430 } 431 432 int EVP_PKEY_CTX_hex2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *hex) 433 { 434 unsigned char *bin; 435 long binlen; 436 int rv = -1; 437 438 bin = OPENSSL_hexstr2buf(hex, &binlen); 439 if (bin == NULL) 440 return 0; 441 if (binlen <= INT_MAX) 442 rv = ctx->pmeth->ctrl(ctx, cmd, binlen, bin); 443 OPENSSL_free(bin); 444 return rv; 445 } 446 447 /* Pass a message digest to a ctrl */ 448 int EVP_PKEY_CTX_md(EVP_PKEY_CTX *ctx, int optype, int cmd, const char *md) 449 { 450 const EVP_MD *m; 451 452 if (md == NULL || (m = EVP_get_digestbyname(md)) == NULL) { 453 EVPerr(EVP_F_EVP_PKEY_CTX_MD, EVP_R_INVALID_DIGEST); 454 return 0; 455 } 456 return EVP_PKEY_CTX_ctrl(ctx, -1, optype, cmd, 0, (void *)m); 457 } 458 459 int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx) 460 { 461 return ctx->operation; 462 } 463 464 void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen) 465 { 466 ctx->keygen_info = dat; 467 ctx->keygen_info_count = datlen; 468 } 469 470 void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data) 471 { 472 ctx->data = data; 473 } 474 475 void *EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx) 476 { 477 return ctx->data; 478 } 479 480 EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx) 481 { 482 return ctx->pkey; 483 } 484 485 EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx) 486 { 487 return ctx->peerkey; 488 } 489 490 void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data) 491 { 492 ctx->app_data = data; 493 } 494 495 void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx) 496 { 497 return ctx->app_data; 498 } 499 500 void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth, 501 int (*init) (EVP_PKEY_CTX *ctx)) 502 { 503 pmeth->init = init; 504 } 505 506 void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth, 507 int (*copy) (EVP_PKEY_CTX *dst, 508 EVP_PKEY_CTX *src)) 509 { 510 pmeth->copy = copy; 511 } 512 513 void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth, 514 void (*cleanup) (EVP_PKEY_CTX *ctx)) 515 { 516 pmeth->cleanup = cleanup; 517 } 518 519 void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth, 520 int (*paramgen_init) (EVP_PKEY_CTX *ctx), 521 int (*paramgen) (EVP_PKEY_CTX *ctx, 522 EVP_PKEY *pkey)) 523 { 524 pmeth->paramgen_init = paramgen_init; 525 pmeth->paramgen = paramgen; 526 } 527 528 void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth, 529 int (*keygen_init) (EVP_PKEY_CTX *ctx), 530 int (*keygen) (EVP_PKEY_CTX *ctx, 531 EVP_PKEY *pkey)) 532 { 533 pmeth->keygen_init = keygen_init; 534 pmeth->keygen = keygen; 535 } 536 537 void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth, 538 int (*sign_init) (EVP_PKEY_CTX *ctx), 539 int (*sign) (EVP_PKEY_CTX *ctx, 540 unsigned char *sig, size_t *siglen, 541 const unsigned char *tbs, 542 size_t tbslen)) 543 { 544 pmeth->sign_init = sign_init; 545 pmeth->sign = sign; 546 } 547 548 void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth, 549 int (*verify_init) (EVP_PKEY_CTX *ctx), 550 int (*verify) (EVP_PKEY_CTX *ctx, 551 const unsigned char *sig, 552 size_t siglen, 553 const unsigned char *tbs, 554 size_t tbslen)) 555 { 556 pmeth->verify_init = verify_init; 557 pmeth->verify = verify; 558 } 559 560 void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth, 561 int (*verify_recover_init) (EVP_PKEY_CTX 562 *ctx), 563 int (*verify_recover) (EVP_PKEY_CTX 564 *ctx, 565 unsigned char 566 *sig, 567 size_t *siglen, 568 const unsigned 569 char *tbs, 570 size_t tbslen)) 571 { 572 pmeth->verify_recover_init = verify_recover_init; 573 pmeth->verify_recover = verify_recover; 574 } 575 576 void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth, 577 int (*signctx_init) (EVP_PKEY_CTX *ctx, 578 EVP_MD_CTX *mctx), 579 int (*signctx) (EVP_PKEY_CTX *ctx, 580 unsigned char *sig, 581 size_t *siglen, 582 EVP_MD_CTX *mctx)) 583 { 584 pmeth->signctx_init = signctx_init; 585 pmeth->signctx = signctx; 586 } 587 588 void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth, 589 int (*verifyctx_init) (EVP_PKEY_CTX *ctx, 590 EVP_MD_CTX *mctx), 591 int (*verifyctx) (EVP_PKEY_CTX *ctx, 592 const unsigned char *sig, 593 int siglen, 594 EVP_MD_CTX *mctx)) 595 { 596 pmeth->verifyctx_init = verifyctx_init; 597 pmeth->verifyctx = verifyctx; 598 } 599 600 void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth, 601 int (*encrypt_init) (EVP_PKEY_CTX *ctx), 602 int (*encryptfn) (EVP_PKEY_CTX *ctx, 603 unsigned char *out, 604 size_t *outlen, 605 const unsigned char *in, 606 size_t inlen)) 607 { 608 pmeth->encrypt_init = encrypt_init; 609 pmeth->encrypt = encryptfn; 610 } 611 612 void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth, 613 int (*decrypt_init) (EVP_PKEY_CTX *ctx), 614 int (*decrypt) (EVP_PKEY_CTX *ctx, 615 unsigned char *out, 616 size_t *outlen, 617 const unsigned char *in, 618 size_t inlen)) 619 { 620 pmeth->decrypt_init = decrypt_init; 621 pmeth->decrypt = decrypt; 622 } 623 624 void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth, 625 int (*derive_init) (EVP_PKEY_CTX *ctx), 626 int (*derive) (EVP_PKEY_CTX *ctx, 627 unsigned char *key, 628 size_t *keylen)) 629 { 630 pmeth->derive_init = derive_init; 631 pmeth->derive = derive; 632 } 633 634 void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth, 635 int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1, 636 void *p2), 637 int (*ctrl_str) (EVP_PKEY_CTX *ctx, 638 const char *type, 639 const char *value)) 640 { 641 pmeth->ctrl = ctrl; 642 pmeth->ctrl_str = ctrl_str; 643 } 644 645 void EVP_PKEY_meth_set_digestsign(EVP_PKEY_METHOD *pmeth, 646 int (*digestsign) (EVP_MD_CTX *ctx, unsigned char *sig, size_t *siglen, 647 const unsigned char *tbs, size_t tbslen)) 648 { 649 pmeth->digestsign = digestsign; 650 } 651 652 void EVP_PKEY_meth_set_digestverify(EVP_PKEY_METHOD *pmeth, 653 int (*digestverify) (EVP_MD_CTX *ctx, const unsigned char *sig, 654 size_t siglen, const unsigned char *tbs, 655 size_t tbslen)) 656 { 657 pmeth->digestverify = digestverify; 658 } 659 660 void EVP_PKEY_meth_set_check(EVP_PKEY_METHOD *pmeth, 661 int (*check) (EVP_PKEY *pkey)) 662 { 663 pmeth->check = check; 664 } 665 666 void EVP_PKEY_meth_set_public_check(EVP_PKEY_METHOD *pmeth, 667 int (*check) (EVP_PKEY *pkey)) 668 { 669 pmeth->public_check = check; 670 } 671 672 void EVP_PKEY_meth_set_param_check(EVP_PKEY_METHOD *pmeth, 673 int (*check) (EVP_PKEY *pkey)) 674 { 675 pmeth->param_check = check; 676 } 677 678 void EVP_PKEY_meth_set_digest_custom(EVP_PKEY_METHOD *pmeth, 679 int (*digest_custom) (EVP_PKEY_CTX *ctx, 680 EVP_MD_CTX *mctx)) 681 { 682 pmeth->digest_custom = digest_custom; 683 } 684 685 void EVP_PKEY_meth_get_init(const EVP_PKEY_METHOD *pmeth, 686 int (**pinit) (EVP_PKEY_CTX *ctx)) 687 { 688 *pinit = pmeth->init; 689 } 690 691 void EVP_PKEY_meth_get_copy(const EVP_PKEY_METHOD *pmeth, 692 int (**pcopy) (EVP_PKEY_CTX *dst, 693 EVP_PKEY_CTX *src)) 694 { 695 *pcopy = pmeth->copy; 696 } 697 698 void EVP_PKEY_meth_get_cleanup(const EVP_PKEY_METHOD *pmeth, 699 void (**pcleanup) (EVP_PKEY_CTX *ctx)) 700 { 701 *pcleanup = pmeth->cleanup; 702 } 703 704 void EVP_PKEY_meth_get_paramgen(const EVP_PKEY_METHOD *pmeth, 705 int (**pparamgen_init) (EVP_PKEY_CTX *ctx), 706 int (**pparamgen) (EVP_PKEY_CTX *ctx, 707 EVP_PKEY *pkey)) 708 { 709 if (pparamgen_init) 710 *pparamgen_init = pmeth->paramgen_init; 711 if (pparamgen) 712 *pparamgen = pmeth->paramgen; 713 } 714 715 void EVP_PKEY_meth_get_keygen(const EVP_PKEY_METHOD *pmeth, 716 int (**pkeygen_init) (EVP_PKEY_CTX *ctx), 717 int (**pkeygen) (EVP_PKEY_CTX *ctx, 718 EVP_PKEY *pkey)) 719 { 720 if (pkeygen_init) 721 *pkeygen_init = pmeth->keygen_init; 722 if (pkeygen) 723 *pkeygen = pmeth->keygen; 724 } 725 726 void EVP_PKEY_meth_get_sign(const EVP_PKEY_METHOD *pmeth, 727 int (**psign_init) (EVP_PKEY_CTX *ctx), 728 int (**psign) (EVP_PKEY_CTX *ctx, 729 unsigned char *sig, size_t *siglen, 730 const unsigned char *tbs, 731 size_t tbslen)) 732 { 733 if (psign_init) 734 *psign_init = pmeth->sign_init; 735 if (psign) 736 *psign = pmeth->sign; 737 } 738 739 void EVP_PKEY_meth_get_verify(const EVP_PKEY_METHOD *pmeth, 740 int (**pverify_init) (EVP_PKEY_CTX *ctx), 741 int (**pverify) (EVP_PKEY_CTX *ctx, 742 const unsigned char *sig, 743 size_t siglen, 744 const unsigned char *tbs, 745 size_t tbslen)) 746 { 747 if (pverify_init) 748 *pverify_init = pmeth->verify_init; 749 if (pverify) 750 *pverify = pmeth->verify; 751 } 752 753 void EVP_PKEY_meth_get_verify_recover(const EVP_PKEY_METHOD *pmeth, 754 int (**pverify_recover_init) (EVP_PKEY_CTX 755 *ctx), 756 int (**pverify_recover) (EVP_PKEY_CTX 757 *ctx, 758 unsigned char 759 *sig, 760 size_t *siglen, 761 const unsigned 762 char *tbs, 763 size_t tbslen)) 764 { 765 if (pverify_recover_init) 766 *pverify_recover_init = pmeth->verify_recover_init; 767 if (pverify_recover) 768 *pverify_recover = pmeth->verify_recover; 769 } 770 771 void EVP_PKEY_meth_get_signctx(const EVP_PKEY_METHOD *pmeth, 772 int (**psignctx_init) (EVP_PKEY_CTX *ctx, 773 EVP_MD_CTX *mctx), 774 int (**psignctx) (EVP_PKEY_CTX *ctx, 775 unsigned char *sig, 776 size_t *siglen, 777 EVP_MD_CTX *mctx)) 778 { 779 if (psignctx_init) 780 *psignctx_init = pmeth->signctx_init; 781 if (psignctx) 782 *psignctx = pmeth->signctx; 783 } 784 785 void EVP_PKEY_meth_get_verifyctx(const EVP_PKEY_METHOD *pmeth, 786 int (**pverifyctx_init) (EVP_PKEY_CTX *ctx, 787 EVP_MD_CTX *mctx), 788 int (**pverifyctx) (EVP_PKEY_CTX *ctx, 789 const unsigned char *sig, 790 int siglen, 791 EVP_MD_CTX *mctx)) 792 { 793 if (pverifyctx_init) 794 *pverifyctx_init = pmeth->verifyctx_init; 795 if (pverifyctx) 796 *pverifyctx = pmeth->verifyctx; 797 } 798 799 void EVP_PKEY_meth_get_encrypt(const EVP_PKEY_METHOD *pmeth, 800 int (**pencrypt_init) (EVP_PKEY_CTX *ctx), 801 int (**pencryptfn) (EVP_PKEY_CTX *ctx, 802 unsigned char *out, 803 size_t *outlen, 804 const unsigned char *in, 805 size_t inlen)) 806 { 807 if (pencrypt_init) 808 *pencrypt_init = pmeth->encrypt_init; 809 if (pencryptfn) 810 *pencryptfn = pmeth->encrypt; 811 } 812 813 void EVP_PKEY_meth_get_decrypt(const EVP_PKEY_METHOD *pmeth, 814 int (**pdecrypt_init) (EVP_PKEY_CTX *ctx), 815 int (**pdecrypt) (EVP_PKEY_CTX *ctx, 816 unsigned char *out, 817 size_t *outlen, 818 const unsigned char *in, 819 size_t inlen)) 820 { 821 if (pdecrypt_init) 822 *pdecrypt_init = pmeth->decrypt_init; 823 if (pdecrypt) 824 *pdecrypt = pmeth->decrypt; 825 } 826 827 void EVP_PKEY_meth_get_derive(const EVP_PKEY_METHOD *pmeth, 828 int (**pderive_init) (EVP_PKEY_CTX *ctx), 829 int (**pderive) (EVP_PKEY_CTX *ctx, 830 unsigned char *key, 831 size_t *keylen)) 832 { 833 if (pderive_init) 834 *pderive_init = pmeth->derive_init; 835 if (pderive) 836 *pderive = pmeth->derive; 837 } 838 839 void EVP_PKEY_meth_get_ctrl(const EVP_PKEY_METHOD *pmeth, 840 int (**pctrl) (EVP_PKEY_CTX *ctx, int type, int p1, 841 void *p2), 842 int (**pctrl_str) (EVP_PKEY_CTX *ctx, 843 const char *type, 844 const char *value)) 845 { 846 if (pctrl) 847 *pctrl = pmeth->ctrl; 848 if (pctrl_str) 849 *pctrl_str = pmeth->ctrl_str; 850 } 851 852 void EVP_PKEY_meth_get_digestsign(EVP_PKEY_METHOD *pmeth, 853 int (**digestsign) (EVP_MD_CTX *ctx, unsigned char *sig, size_t *siglen, 854 const unsigned char *tbs, size_t tbslen)) 855 { 856 if (digestsign) 857 *digestsign = pmeth->digestsign; 858 } 859 860 void EVP_PKEY_meth_get_digestverify(EVP_PKEY_METHOD *pmeth, 861 int (**digestverify) (EVP_MD_CTX *ctx, const unsigned char *sig, 862 size_t siglen, const unsigned char *tbs, 863 size_t tbslen)) 864 { 865 if (digestverify) 866 *digestverify = pmeth->digestverify; 867 } 868 869 void EVP_PKEY_meth_get_check(const EVP_PKEY_METHOD *pmeth, 870 int (**pcheck) (EVP_PKEY *pkey)) 871 { 872 if (pcheck != NULL) 873 *pcheck = pmeth->check; 874 } 875 876 void EVP_PKEY_meth_get_public_check(const EVP_PKEY_METHOD *pmeth, 877 int (**pcheck) (EVP_PKEY *pkey)) 878 { 879 if (pcheck != NULL) 880 *pcheck = pmeth->public_check; 881 } 882 883 void EVP_PKEY_meth_get_param_check(const EVP_PKEY_METHOD *pmeth, 884 int (**pcheck) (EVP_PKEY *pkey)) 885 { 886 if (pcheck != NULL) 887 *pcheck = pmeth->param_check; 888 } 889 890 void EVP_PKEY_meth_get_digest_custom(EVP_PKEY_METHOD *pmeth, 891 int (**pdigest_custom) (EVP_PKEY_CTX *ctx, 892 EVP_MD_CTX *mctx)) 893 { 894 if (pdigest_custom != NULL) 895 *pdigest_custom = pmeth->digest_custom; 896 } 897