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