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