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