rsa_pmeth.c revision 296341
1/* crypto/rsa/rsa_pmeth.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 "cryptlib.h" 62#include <openssl/asn1t.h> 63#include <openssl/x509.h> 64#include <openssl/rsa.h> 65#include <openssl/bn.h> 66#include <openssl/evp.h> 67#ifndef OPENSSL_NO_CMS 68# include <openssl/cms.h> 69#endif 70#ifdef OPENSSL_FIPS 71# include <openssl/fips.h> 72#endif 73#include "evp_locl.h" 74#include "rsa_locl.h" 75 76/* RSA pkey context structure */ 77 78typedef struct { 79 /* Key gen parameters */ 80 int nbits; 81 BIGNUM *pub_exp; 82 /* Keygen callback info */ 83 int gentmp[2]; 84 /* RSA padding mode */ 85 int pad_mode; 86 /* message digest */ 87 const EVP_MD *md; 88 /* message digest for MGF1 */ 89 const EVP_MD *mgf1md; 90 /* PSS/OAEP salt length */ 91 int saltlen; 92 /* Temp buffer */ 93 unsigned char *tbuf; 94} RSA_PKEY_CTX; 95 96static int pkey_rsa_init(EVP_PKEY_CTX *ctx) 97{ 98 RSA_PKEY_CTX *rctx; 99 rctx = OPENSSL_malloc(sizeof(RSA_PKEY_CTX)); 100 if (!rctx) 101 return 0; 102 rctx->nbits = 1024; 103 rctx->pub_exp = NULL; 104 rctx->pad_mode = RSA_PKCS1_PADDING; 105 rctx->md = NULL; 106 rctx->mgf1md = NULL; 107 rctx->tbuf = NULL; 108 109 rctx->saltlen = -2; 110 111 ctx->data = rctx; 112 ctx->keygen_info = rctx->gentmp; 113 ctx->keygen_info_count = 2; 114 115 return 1; 116} 117 118static int pkey_rsa_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src) 119{ 120 RSA_PKEY_CTX *dctx, *sctx; 121 if (!pkey_rsa_init(dst)) 122 return 0; 123 sctx = src->data; 124 dctx = dst->data; 125 dctx->nbits = sctx->nbits; 126 if (sctx->pub_exp) { 127 dctx->pub_exp = BN_dup(sctx->pub_exp); 128 if (!dctx->pub_exp) 129 return 0; 130 } 131 dctx->pad_mode = sctx->pad_mode; 132 dctx->md = sctx->md; 133 return 1; 134} 135 136static int setup_tbuf(RSA_PKEY_CTX *ctx, EVP_PKEY_CTX *pk) 137{ 138 if (ctx->tbuf) 139 return 1; 140 ctx->tbuf = OPENSSL_malloc(EVP_PKEY_size(pk->pkey)); 141 if (!ctx->tbuf) 142 return 0; 143 return 1; 144} 145 146static void pkey_rsa_cleanup(EVP_PKEY_CTX *ctx) 147{ 148 RSA_PKEY_CTX *rctx = ctx->data; 149 if (rctx) { 150 if (rctx->pub_exp) 151 BN_free(rctx->pub_exp); 152 if (rctx->tbuf) 153 OPENSSL_free(rctx->tbuf); 154 OPENSSL_free(rctx); 155 } 156} 157 158#ifdef OPENSSL_FIPS 159/* 160 * FIP checker. Return value indicates status of context parameters: 1 : 161 * redirect to FIPS. 0 : don't redirect to FIPS. -1 : illegal operation in 162 * FIPS mode. 163 */ 164 165static int pkey_fips_check_ctx(EVP_PKEY_CTX *ctx) 166{ 167 RSA_PKEY_CTX *rctx = ctx->data; 168 RSA *rsa = ctx->pkey->pkey.rsa; 169 int rv = -1; 170 if (!FIPS_mode()) 171 return 0; 172 if (rsa->flags & RSA_FLAG_NON_FIPS_ALLOW) 173 rv = 0; 174 if (!(rsa->meth->flags & RSA_FLAG_FIPS_METHOD) && rv) 175 return -1; 176 if (rctx->md && !(rctx->md->flags & EVP_MD_FLAG_FIPS)) 177 return rv; 178 if (rctx->mgf1md && !(rctx->mgf1md->flags & EVP_MD_FLAG_FIPS)) 179 return rv; 180 return 1; 181} 182#endif 183 184static int pkey_rsa_sign(EVP_PKEY_CTX *ctx, unsigned char *sig, 185 size_t *siglen, const unsigned char *tbs, 186 size_t tbslen) 187{ 188 int ret; 189 RSA_PKEY_CTX *rctx = ctx->data; 190 RSA *rsa = ctx->pkey->pkey.rsa; 191 192#ifdef OPENSSL_FIPS 193 ret = pkey_fips_check_ctx(ctx); 194 if (ret < 0) { 195 RSAerr(RSA_F_PKEY_RSA_SIGN, RSA_R_OPERATION_NOT_ALLOWED_IN_FIPS_MODE); 196 return -1; 197 } 198#endif 199 200 if (rctx->md) { 201 if (tbslen != (size_t)EVP_MD_size(rctx->md)) { 202 RSAerr(RSA_F_PKEY_RSA_SIGN, RSA_R_INVALID_DIGEST_LENGTH); 203 return -1; 204 } 205#ifdef OPENSSL_FIPS 206 if (ret > 0) { 207 unsigned int slen; 208 ret = FIPS_rsa_sign_digest(rsa, tbs, tbslen, rctx->md, 209 rctx->pad_mode, 210 rctx->saltlen, 211 rctx->mgf1md, sig, &slen); 212 if (ret > 0) 213 *siglen = slen; 214 else 215 *siglen = 0; 216 return ret; 217 } 218#endif 219 220 if (EVP_MD_type(rctx->md) == NID_mdc2) { 221 unsigned int sltmp; 222 if (rctx->pad_mode != RSA_PKCS1_PADDING) 223 return -1; 224 ret = RSA_sign_ASN1_OCTET_STRING(NID_mdc2, 225 tbs, tbslen, sig, &sltmp, rsa); 226 227 if (ret <= 0) 228 return ret; 229 ret = sltmp; 230 } else if (rctx->pad_mode == RSA_X931_PADDING) { 231 if ((size_t)EVP_PKEY_size(ctx->pkey) < tbslen + 1) { 232 RSAerr(RSA_F_PKEY_RSA_SIGN, RSA_R_KEY_SIZE_TOO_SMALL); 233 return -1; 234 } 235 if (!setup_tbuf(rctx, ctx)) { 236 RSAerr(RSA_F_PKEY_RSA_SIGN, ERR_R_MALLOC_FAILURE); 237 return -1; 238 } 239 memcpy(rctx->tbuf, tbs, tbslen); 240 rctx->tbuf[tbslen] = RSA_X931_hash_id(EVP_MD_type(rctx->md)); 241 ret = RSA_private_encrypt(tbslen + 1, rctx->tbuf, 242 sig, rsa, RSA_X931_PADDING); 243 } else if (rctx->pad_mode == RSA_PKCS1_PADDING) { 244 unsigned int sltmp; 245 ret = RSA_sign(EVP_MD_type(rctx->md), 246 tbs, tbslen, sig, &sltmp, rsa); 247 if (ret <= 0) 248 return ret; 249 ret = sltmp; 250 } else if (rctx->pad_mode == RSA_PKCS1_PSS_PADDING) { 251 if (!setup_tbuf(rctx, ctx)) 252 return -1; 253 if (!RSA_padding_add_PKCS1_PSS_mgf1(rsa, 254 rctx->tbuf, tbs, 255 rctx->md, rctx->mgf1md, 256 rctx->saltlen)) 257 return -1; 258 ret = RSA_private_encrypt(RSA_size(rsa), rctx->tbuf, 259 sig, rsa, RSA_NO_PADDING); 260 } else 261 return -1; 262 } else 263 ret = RSA_private_encrypt(tbslen, tbs, sig, ctx->pkey->pkey.rsa, 264 rctx->pad_mode); 265 if (ret < 0) 266 return ret; 267 *siglen = ret; 268 return 1; 269} 270 271static int pkey_rsa_verifyrecover(EVP_PKEY_CTX *ctx, 272 unsigned char *rout, size_t *routlen, 273 const unsigned char *sig, size_t siglen) 274{ 275 int ret; 276 RSA_PKEY_CTX *rctx = ctx->data; 277 278 if (rctx->md) { 279 if (rctx->pad_mode == RSA_X931_PADDING) { 280 if (!setup_tbuf(rctx, ctx)) 281 return -1; 282 ret = RSA_public_decrypt(siglen, sig, 283 rctx->tbuf, ctx->pkey->pkey.rsa, 284 RSA_X931_PADDING); 285 if (ret < 1) 286 return 0; 287 ret--; 288 if (rctx->tbuf[ret] != RSA_X931_hash_id(EVP_MD_type(rctx->md))) { 289 RSAerr(RSA_F_PKEY_RSA_VERIFYRECOVER, 290 RSA_R_ALGORITHM_MISMATCH); 291 return 0; 292 } 293 if (ret != EVP_MD_size(rctx->md)) { 294 RSAerr(RSA_F_PKEY_RSA_VERIFYRECOVER, 295 RSA_R_INVALID_DIGEST_LENGTH); 296 return 0; 297 } 298 if (rout) 299 memcpy(rout, rctx->tbuf, ret); 300 } else if (rctx->pad_mode == RSA_PKCS1_PADDING) { 301 size_t sltmp; 302 ret = int_rsa_verify(EVP_MD_type(rctx->md), 303 NULL, 0, rout, &sltmp, 304 sig, siglen, ctx->pkey->pkey.rsa); 305 if (ret <= 0) 306 return 0; 307 ret = sltmp; 308 } else 309 return -1; 310 } else 311 ret = RSA_public_decrypt(siglen, sig, rout, ctx->pkey->pkey.rsa, 312 rctx->pad_mode); 313 if (ret < 0) 314 return ret; 315 *routlen = ret; 316 return 1; 317} 318 319static int pkey_rsa_verify(EVP_PKEY_CTX *ctx, 320 const unsigned char *sig, size_t siglen, 321 const unsigned char *tbs, size_t tbslen) 322{ 323 RSA_PKEY_CTX *rctx = ctx->data; 324 RSA *rsa = ctx->pkey->pkey.rsa; 325 size_t rslen; 326#ifdef OPENSSL_FIPS 327 int rv; 328 rv = pkey_fips_check_ctx(ctx); 329 if (rv < 0) { 330 RSAerr(RSA_F_PKEY_RSA_VERIFY, 331 RSA_R_OPERATION_NOT_ALLOWED_IN_FIPS_MODE); 332 return -1; 333 } 334#endif 335 if (rctx->md) { 336#ifdef OPENSSL_FIPS 337 if (rv > 0) { 338 return FIPS_rsa_verify_digest(rsa, 339 tbs, tbslen, 340 rctx->md, 341 rctx->pad_mode, 342 rctx->saltlen, 343 rctx->mgf1md, sig, siglen); 344 345 } 346#endif 347 if (rctx->pad_mode == RSA_PKCS1_PADDING) 348 return RSA_verify(EVP_MD_type(rctx->md), tbs, tbslen, 349 sig, siglen, rsa); 350 if (rctx->pad_mode == RSA_X931_PADDING) { 351 if (pkey_rsa_verifyrecover(ctx, NULL, &rslen, sig, siglen) <= 0) 352 return 0; 353 } else if (rctx->pad_mode == RSA_PKCS1_PSS_PADDING) { 354 int ret; 355 if (!setup_tbuf(rctx, ctx)) 356 return -1; 357 ret = RSA_public_decrypt(siglen, sig, rctx->tbuf, 358 rsa, RSA_NO_PADDING); 359 if (ret <= 0) 360 return 0; 361 ret = RSA_verify_PKCS1_PSS_mgf1(rsa, tbs, 362 rctx->md, rctx->mgf1md, 363 rctx->tbuf, rctx->saltlen); 364 if (ret <= 0) 365 return 0; 366 return 1; 367 } else 368 return -1; 369 } else { 370 if (!setup_tbuf(rctx, ctx)) 371 return -1; 372 rslen = RSA_public_decrypt(siglen, sig, rctx->tbuf, 373 rsa, rctx->pad_mode); 374 if (rslen == 0) 375 return 0; 376 } 377 378 if ((rslen != tbslen) || memcmp(tbs, rctx->tbuf, rslen)) 379 return 0; 380 381 return 1; 382 383} 384 385static int pkey_rsa_encrypt(EVP_PKEY_CTX *ctx, 386 unsigned char *out, size_t *outlen, 387 const unsigned char *in, size_t inlen) 388{ 389 int ret; 390 RSA_PKEY_CTX *rctx = ctx->data; 391 ret = RSA_public_encrypt(inlen, in, out, ctx->pkey->pkey.rsa, 392 rctx->pad_mode); 393 if (ret < 0) 394 return ret; 395 *outlen = ret; 396 return 1; 397} 398 399static int pkey_rsa_decrypt(EVP_PKEY_CTX *ctx, 400 unsigned char *out, size_t *outlen, 401 const unsigned char *in, size_t inlen) 402{ 403 int ret; 404 RSA_PKEY_CTX *rctx = ctx->data; 405 ret = RSA_private_decrypt(inlen, in, out, ctx->pkey->pkey.rsa, 406 rctx->pad_mode); 407 if (ret < 0) 408 return ret; 409 *outlen = ret; 410 return 1; 411} 412 413static int check_padding_md(const EVP_MD *md, int padding) 414{ 415 if (!md) 416 return 1; 417 418 if (padding == RSA_NO_PADDING) { 419 RSAerr(RSA_F_CHECK_PADDING_MD, RSA_R_INVALID_PADDING_MODE); 420 return 0; 421 } 422 423 if (padding == RSA_X931_PADDING) { 424 if (RSA_X931_hash_id(EVP_MD_type(md)) == -1) { 425 RSAerr(RSA_F_CHECK_PADDING_MD, RSA_R_INVALID_X931_DIGEST); 426 return 0; 427 } 428 return 1; 429 } 430 431 return 1; 432} 433 434static int pkey_rsa_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2) 435{ 436 RSA_PKEY_CTX *rctx = ctx->data; 437 switch (type) { 438 case EVP_PKEY_CTRL_RSA_PADDING: 439 if ((p1 >= RSA_PKCS1_PADDING) && (p1 <= RSA_PKCS1_PSS_PADDING)) { 440 if (!check_padding_md(rctx->md, p1)) 441 return 0; 442 if (p1 == RSA_PKCS1_PSS_PADDING) { 443 if (!(ctx->operation & 444 (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY))) 445 goto bad_pad; 446 if (!rctx->md) 447 rctx->md = EVP_sha1(); 448 } 449 if (p1 == RSA_PKCS1_OAEP_PADDING) { 450 if (!(ctx->operation & EVP_PKEY_OP_TYPE_CRYPT)) 451 goto bad_pad; 452 if (!rctx->md) 453 rctx->md = EVP_sha1(); 454 } 455 rctx->pad_mode = p1; 456 return 1; 457 } 458 bad_pad: 459 RSAerr(RSA_F_PKEY_RSA_CTRL, 460 RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE); 461 return -2; 462 463 case EVP_PKEY_CTRL_GET_RSA_PADDING: 464 *(int *)p2 = rctx->pad_mode; 465 return 1; 466 467 case EVP_PKEY_CTRL_RSA_PSS_SALTLEN: 468 case EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN: 469 if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING) { 470 RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PSS_SALTLEN); 471 return -2; 472 } 473 if (type == EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN) 474 *(int *)p2 = rctx->saltlen; 475 else { 476 if (p1 < -2) 477 return -2; 478 rctx->saltlen = p1; 479 } 480 return 1; 481 482 case EVP_PKEY_CTRL_RSA_KEYGEN_BITS: 483 if (p1 < 256) { 484 RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_KEYBITS); 485 return -2; 486 } 487 rctx->nbits = p1; 488 return 1; 489 490 case EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP: 491 if (!p2) 492 return -2; 493 rctx->pub_exp = p2; 494 return 1; 495 496 case EVP_PKEY_CTRL_MD: 497 if (!check_padding_md(p2, rctx->pad_mode)) 498 return 0; 499 rctx->md = p2; 500 return 1; 501 502 case EVP_PKEY_CTRL_RSA_MGF1_MD: 503 case EVP_PKEY_CTRL_GET_RSA_MGF1_MD: 504 if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING) { 505 RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_MGF1_MD); 506 return -2; 507 } 508 if (type == EVP_PKEY_CTRL_GET_RSA_MGF1_MD) { 509 if (rctx->mgf1md) 510 *(const EVP_MD **)p2 = rctx->mgf1md; 511 else 512 *(const EVP_MD **)p2 = rctx->md; 513 } else 514 rctx->mgf1md = p2; 515 return 1; 516 517 case EVP_PKEY_CTRL_DIGESTINIT: 518 case EVP_PKEY_CTRL_PKCS7_ENCRYPT: 519 case EVP_PKEY_CTRL_PKCS7_DECRYPT: 520 case EVP_PKEY_CTRL_PKCS7_SIGN: 521 return 1; 522#ifndef OPENSSL_NO_CMS 523 case EVP_PKEY_CTRL_CMS_DECRYPT: 524 { 525 X509_ALGOR *alg = NULL; 526 ASN1_OBJECT *encalg = NULL; 527 if (p2) 528 CMS_RecipientInfo_ktri_get0_algs(p2, NULL, NULL, &alg); 529 if (alg) 530 X509_ALGOR_get0(&encalg, NULL, NULL, alg); 531 if (encalg && OBJ_obj2nid(encalg) == NID_rsaesOaep) 532 rctx->pad_mode = RSA_PKCS1_OAEP_PADDING; 533 } 534 case EVP_PKEY_CTRL_CMS_ENCRYPT: 535 case EVP_PKEY_CTRL_CMS_SIGN: 536 return 1; 537#endif 538 case EVP_PKEY_CTRL_PEER_KEY: 539 RSAerr(RSA_F_PKEY_RSA_CTRL, 540 RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE); 541 return -2; 542 543 default: 544 return -2; 545 546 } 547} 548 549static int pkey_rsa_ctrl_str(EVP_PKEY_CTX *ctx, 550 const char *type, const char *value) 551{ 552 if (!value) { 553 RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_VALUE_MISSING); 554 return 0; 555 } 556 if (!strcmp(type, "rsa_padding_mode")) { 557 int pm; 558 if (!strcmp(value, "pkcs1")) 559 pm = RSA_PKCS1_PADDING; 560 else if (!strcmp(value, "sslv23")) 561 pm = RSA_SSLV23_PADDING; 562 else if (!strcmp(value, "none")) 563 pm = RSA_NO_PADDING; 564 else if (!strcmp(value, "oeap")) 565 pm = RSA_PKCS1_OAEP_PADDING; 566 else if (!strcmp(value, "oaep")) 567 pm = RSA_PKCS1_OAEP_PADDING; 568 else if (!strcmp(value, "x931")) 569 pm = RSA_X931_PADDING; 570 else if (!strcmp(value, "pss")) 571 pm = RSA_PKCS1_PSS_PADDING; 572 else { 573 RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_UNKNOWN_PADDING_TYPE); 574 return -2; 575 } 576 return EVP_PKEY_CTX_set_rsa_padding(ctx, pm); 577 } 578 579 if (!strcmp(type, "rsa_pss_saltlen")) { 580 int saltlen; 581 saltlen = atoi(value); 582 return EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, saltlen); 583 } 584 585 if (!strcmp(type, "rsa_keygen_bits")) { 586 int nbits; 587 nbits = atoi(value); 588 return EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, nbits); 589 } 590 591 if (!strcmp(type, "rsa_keygen_pubexp")) { 592 int ret; 593 BIGNUM *pubexp = NULL; 594 if (!BN_asc2bn(&pubexp, value)) 595 return 0; 596 ret = EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx, pubexp); 597 if (ret <= 0) 598 BN_free(pubexp); 599 return ret; 600 } 601 602 return -2; 603} 604 605static int pkey_rsa_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) 606{ 607 RSA *rsa = NULL; 608 RSA_PKEY_CTX *rctx = ctx->data; 609 BN_GENCB *pcb, cb; 610 int ret; 611 if (!rctx->pub_exp) { 612 rctx->pub_exp = BN_new(); 613 if (!rctx->pub_exp || !BN_set_word(rctx->pub_exp, RSA_F4)) 614 return 0; 615 } 616 rsa = RSA_new(); 617 if (!rsa) 618 return 0; 619 if (ctx->pkey_gencb) { 620 pcb = &cb; 621 evp_pkey_set_cb_translate(pcb, ctx); 622 } else 623 pcb = NULL; 624 ret = RSA_generate_key_ex(rsa, rctx->nbits, rctx->pub_exp, pcb); 625 if (ret > 0) 626 EVP_PKEY_assign_RSA(pkey, rsa); 627 else 628 RSA_free(rsa); 629 return ret; 630} 631 632const EVP_PKEY_METHOD rsa_pkey_meth = { 633 EVP_PKEY_RSA, 634 EVP_PKEY_FLAG_AUTOARGLEN, 635 pkey_rsa_init, 636 pkey_rsa_copy, 637 pkey_rsa_cleanup, 638 639 0, 0, 640 641 0, 642 pkey_rsa_keygen, 643 644 0, 645 pkey_rsa_sign, 646 647 0, 648 pkey_rsa_verify, 649 650 0, 651 pkey_rsa_verifyrecover, 652 653 0, 0, 0, 0, 654 655 0, 656 pkey_rsa_encrypt, 657 658 0, 659 pkey_rsa_decrypt, 660 661 0, 0, 662 663 pkey_rsa_ctrl, 664 pkey_rsa_ctrl_str 665}; 666