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